Month: December 2016

Posted on by — Leave a comment

Against cryptoviruses

The cryptovirus or ransomware can enter into our computer. No matter what we are trained to recognize suspicious emails. Sometimes we are tired, distracted and our level of attention is lowered. “They” are increasingly clever and good at making us make mistakes. We open attachments that we should not open. At this point, the damage is done. The virus encrypt a file at a time very quickly: we estimated that the virus is able to encrypt 10,000 files in 30 minutes. After encrypting files on your computer, it starts to encrypt the files of all network folders where able to enter: servers, your colleagues’s of computers. The damage can be incalculable. In our experience there is no anti-virus that can counter it. When the virus starts to encrypt your files, you do not notice anything until it’s too late, when everything is over: the virus manifests itself by changing the image of your desktop with a message: “All your files are encrypted . If you want to get them back you have to pay a ransom. ”

If we had realized the infection once it has started, we would have definitely lost something but we could limit the damage.

Based on these considerations, we have created a very simple program that checks the contents of your personal folders and alerts you via email if a virus is altering the content. The alert can only be sent to you or in conjunction with other email addresses. After receiving the message, turn off, without hesitation, the computer by pushing the power button: better to risk breaking the power supply, which can be replaced cheaply, rather than losing all your files.

The program is completely free and you can download it here: MECDATA DAWN OF JUSTICE. Our response to CryptoVirus.

Once installed, launch it. The program will ask you, the configuration. The only thing you need to enter is the list of email addresses that you will need to alert in case of infection.

At this point, the program starts and you can see the icon on the bar at the bottom. Through this icon you can enter again in the configuration to add or change email addresses.

For lovers of performance, This program is running 18 Mb of RAM and does not impact on the processor. It does not work on Windows XP.

We sincerely wish that there is useful, but if it were, in the last test, the scanner detected the infection only two minutes after the beginning of the same.

We suggest you install it. It does not solve, but improves.

Our additional tips

  • Do not open attachments to emails from strangers, especially if they are not email you expect.
  • Double check your emails from people you know
  • Do not disable the macro block of the products such as Microsoft Word or Excel
  • Back up files regularly
  • Backup up in cloud
  • Do not create file shares and folders with permissions to ‘Everyone’
  • Share folders only to users or groups strictly necessary
Posted on by — Leave a comment

ASP.NET MVC – First Controller

Visual Studio creates the Controller of Model. Let’s see how.

After creating the Model, Student.cs, in the project, in Visual Studio, position yourself on the Controllers directory. Push the right mouse button and press “Add” -> “Controller”. There appears a mask that offers you to choose the type of controller that you want to create. First on the list it is an empty controller, that is, a class that you have to write independently. The third should be a controller of type “Controller with View, using Entity Framework .” Visual Studio, starting with our Model, creates for us the Controller and view all of the CRUD operations. Choose this type.

Now appears a very important mask. From the top you are asked to choose:

  • Model Class. There is a drop-down menu that is automatically filled with all the classes in the Model (and all the classes in your project). Student choose.
  • Date Class context. You must choose the connection to the database that contains your table. The drop down menu shows all the classes in the project, derived from DbContext class,
  • Check “Generate Views” and “use a Page Layout“.
  • Controller name. Visual Studio there proposes a name one based on the Model you’ve selected. You can change the name, but let the word Controller at the end. (Eg. StudentsController)

Before having to set up the Controller, Visual Studio gives you everything you have written in the models and in DbContext is “right.” If the operation is successful now, in the Controllers directory you find the file StudentsController.cs.

Let’s examine this file. You are inside the class StudentsController derived from Controller.

public class StudentsController : Controller
 {
 private ApplicationDbContext db = new ApplicationDbContext();

// GET: Students
 public ActionResult Index()
 {
 return View(db.Students.ToList());
 }

The class immediately initializes a connection to the database (db).

The first function we see is Index(). It ‘was created automatically and allow us to see the list of our students. Each function of this type is called “Action.” When, in our site we require a list of Students, we launch the Index function of the controller Students according to this path:

http://www.mysite.com/Students/Index

The Index function requires, from the connection to the database, all students (db.Students) and turns them into a list (db.Students.ToList ()). At this point sends our list of students to the view (return View (db.Students.ToList ());) As you can see, there isn’t the name of view but only a generic command “View”. The controller  searches in the list of views, for a view  called exactly like the function (Index) and … we see the students.

In the project, in the directory Views, you will find a folder Student with a list of automatically created files (we’ll analyze the view shortly). In the View directory will find the Shared directory. We can say that this directory contains all the “User Controls” ; all interface items that we intend to use in multiple pages; It contains all of the view that are used by other views. Even the one that in the past called “master page” is located here, in the form of “layout”. Look for the _Layout.cshtml file. This is the website of your graphics (we’ll analyze in detail, soon). Find  this piece of code:

<ul class="nav navbar-nav">
 <li>@Html.ActionLink("Home", "Index", "Home")</li>
 <li>@Html.ActionLink("About", "About", "Home")</li>
 <li>@Html.ActionLink("Contact", "Contact", "Home")</li>

These are the buttons you see above, when you launch your site. We need to see a new button to call the student page.

Add to this list html:

<li>@Html.ActionLink("My Student", "Index", "Students")</li>

Then we analyze the ActionLink component.

ActionLink (“Text Displayed”, “Name of Action,” Name of the Controller “). So we will have a button that when pushed will take us to http://www.mysite.com/Students/Index page.

Try running the application and perform a login to test that everything is working.

Posted on by

ASP.NET MVC. first Model – Code first

In this article we will create something new in our project. We will use the “Code First” approach, that is, “first” will write the code. It seems trite to say, but Visual Studio allows, for example, even the “Database First” approach.

Go into the Model directory and create a new class, for example Student.cs.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MySite.Models
{
 public class Student
 {
 }
}

Add this namespace

using System.ComponentModel.DataAnnotations.Schema;

Our model / class is the representation, through its properties, a table that we will build into the database. First of all, let’s talk to the class as it is called to the table that we are preparing.

[Table("STUDENTS")]
 public class Student
 {
 }

Then we create the properties – fields of the table. Add this namespace:

using System.ComponentModel.DataAnnotations;

our table consists of three fields

[Table("STUDENTS")]
 public class Student
 {
 [Key]
 [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
 public int ID { get; set; }

[Required]
 [StringLength(200)]
 [Display(Name = "Name")]
 public string NAME { get; set; }

[StringLength(300)]
 [Display(Name = "Surname")]
 public string SURNAME { get; set; }
 }

The DataAnnotation, written on properties, defining the characteristics of the table fields: ID is the primary key (key), and SQLServer be responsible for assigning the number (DatabaseGeneratedOption.Identity). NAME is a required field (Required) of length 200, the description of which, during a display, it will be “Name” .etc.

Now we must add to DbContext the presence of this table. Open the ApplicationDbContext class and add, as a property, the new table:

public DbSet<Student> Students { get; set; }

Try running the application and perform a login to test that everything is working. Go to the database and built the table complying with his name and the names of the properties of the class.

Posted on by

ASP.NET MVC : DATABASE CONNECTION

ApplicationDbContext

In the previous article we introduced the ApplicationDbContext class.

Search it in the project. You should find it within the IdentityModels.cs file. This class derives from the class that derives from IdentityDbContext DbContext.

DbContext is the connection class to a database. The class constructor has as a parameter the name of the connection string that we had previously found in the Web.config file.

public ApplicationDbContext() : base("DefaultConnection")
 {
 }

Let’s think about this information: in the Web.config you can put more connection strings, and then test the application on different databases, changing the parameter above, or you can create an application that connects to different databases by defining more than one DbContext.

Within a DbContext will be referenced all tables in the database we want to use in our application: or rather, all the tables that have constraints between them.

If for example we want to bind to the table of users created by Visual Studio, a second table created by us, the two tables should be part of the same DbContext. But we know nothing of the tables for the management of users created automatically. The class IdentityDbContext contains references to these tables. For this reason, our ApplicationDbContext not derived from DbContext but IdentityDBContext that contains, in fact, a little more information.

As you add tables for your application, you will work on ApplicationDbContext class. For a neater code, you go to create a new file in ApplicationDbContext.cs Models directory and copy, in this class, the ApplicationDbContext code (the only) which is IdentityModels.cs.

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
 {
     public ApplicationDbContext()
     : base("DefaultConnection")
     {
     }

     public static ApplicationDbContext Create()
     {
       return new ApplicationDbContext();
     }
 }

Try running the application and perform a login to test that everything is working.