Monthly Archive July 2019

ByJayanthi

Face app

Reading Time: 3 minutes

It seems the online world is embroiled in some sort of controversy or the other giving me plenty to write about!! 😉 Jokes aside – have you downloaded and used the currently viral ‘Face app’?   If you have or have not yet done so, read on…

What is ‘Face app’?

‘Face app’ – the AI , face editor is a freely downloadable app for both Android and iOS platforms and is owned by a Russian company Wireless Labs. It is available both on Google Play and Apple App store. I downloaded it and it was really fun to try the different looks(with a smile, without a smile, with makeup, without makeup) and the younger version and older version of oneself are phenomenal too…For a moment, I threw all my security caution to the wind and dissolved into it and enjoyed it!! 🙂 But, not for long… 

The ‘Face app’ asks for your permission to access the pictures from your ‘Gallery’ and no sooner, do you give it the permission – it takes your ‘face’ from a picture and performs a lot of magic to it. It definitely keeps you enthralled and even has options to use your pictures from social media platforms such as ‘Facebook’.

What is all the noise about ‘Face app’ now?

On the face of it, ‘Face app’ seems to be another app for everyone to have a bit of fun online, but there is more to what meets the eye. Your pictures are all uploaded to the cloud which itself is unnerving from a privacy standpoint. Along with this, there is another problem that has been reported widely which is in the ‘Terms and conditions’ of the viral app. The ‘Terms and conditions’ state this:

“You grant FaceApp a perpetual, irrevocable, nonexclusive, royalty-free, worldwide, fully-paid, transferable sub-licensable license to use, reproduce, modify, adapt, publish, translate, create derivative works from, distribute, publicly perform and display your User Content and any name, username or likeness provided in connection with your User Content in all media formats and channels now known or later developed, without compensation to you..”

While you own your “face” content, you are giving the app exclusive rights for your “face” content to be stored perpetually and be used for other derivative works and display it anywhere!! (yikes) I cannot imagine my face being stored on some strange servers in some part of the world and being used for strange purposes!! 

This is the part of the ‘Faceapp’ that is deeply troubling for all users of the Internet community today.

What is being done then?

  1. US Senate minority leader, Chuck Schumer has called on the FBI and Federal Trade Commission to look into the privacy issues with ‘Faceapp'(Source: economictimes.com)
  2. In the wake of privacy concerns, the CEO of Faceapp has stated that most of the pictures are deleted within 48 hours(Source: https://techcrunch.com/2019/07/17/faceapp-responds-to-privacy-concerns/)
  3. User data is definitely not transferred to Russia
  4. Users can requests their data to be deleted
  5. Only the selected picture is uploaded and not all the pictures from the ‘Gallery’ are uploaded

The net result of heavy outburst on social media unfortunately or fortunately, the downloads for ‘Faceapp’ have supposedly increased by 500% in the last six days(Source: https://www.forbes.com/sites/johnkoetsier/2019/07/18/controversy-good-for-business-faceapp-downloads-jumped-561/#759ad9c3577c)

My take on the whole Faceapp drama:

While privacy issues constantly rake the online world, this is probably one of the few times that even non-serious security individuals have woken up to security and privacy thoughts. While our entire online data(conversations, payments, locations, group pictures, events, gatherings) is always moving silently behind the computer screen, a picture of a “face” moving around has really shaken everybody up( A picture is definitely worth a thousand words 🙂 !! ) More people are questioning the privacy behind the fun which is definitely a good thing.

We will see how the ‘Faceapp’ drama unfolds further but for now it is good to see ‘Faceapp’ has definitely woken up the sleeping privacy giant in all of us!!

Cheers!

 

ByJayanthi

Are you a “Cyberchrondriac?” or a “Script kiddie?”

Reading Time: 2 minutes

Cyberchrondriac:

I am sure most of us have heard of the term “hyperchrondriac”. A “hyperchrondriac” is a person who is excessively worried about their health and imagines any minor ailment as a major health concern. Combine this feeling with today’s Internet usage and we have a “cyberchrondriac”!

A “cyberchrondriac” is a person who is guilty of combing the Internet for any or more information about their health concerns. They read various things on the Internet about the minor symptoms that they may have and imagine that they have a terrible disease. With more and  more medical terms and information freely available on the Internet, we all become “cyberchrondriacs” at one time or the other. Their medical ailments may be unfounded or real – but they definitely add to the misery of doctors who are trying to diagnose the real problem. Best option for all “cyberchrondriacs” is to seek medical advice right away and not do a lot of medical research on the Internet…

Script kiddies:

The Internet is our oyster now. We can do anything and everything with its might.We can crack, cook, code, learn and more with the Internet… then why not “hack”? Those looking to hack into websites can learn a great deal by a single minded effort to learn malicious things online. This is where “script kiddies” step in…

‘Script kiddies’ is the name given to newbie hackers. These newbie hackers are not professional hackers and have not perfected the art of ‘hacking’. ‘Script kiddies’ are those who have learnt to hack by reading various articles and publications and watching several online videos on hacking. They also steal other people’s code as they lack enough programming knowledge to wield an attack. In spite of the fact that they are “professional hackers” in the making, their attacks still do affect the majority of users in an equally harmful way. ‘Script kiddies’ do all this and more for the excitement of it and to get joyous bragging rights.

This post saw a definition of a few terms on the Information security front…Stay tuned for more technical updates..

 

 

ByBala Manikandan

ArrayLists: Dynamic Arrays in Java (Part 2)

Reading Time: 3 minutes

Here is the second post on ArrayLists which is a continuation from part 1 . Here are some points covered in the first part:

  • Main advantage of ArrayLists over arrays
  • Creating an ArrayList
  • Adding elements to ArrayLists
  • Iterating through the elements
  • Modifying and deleting elements

In the next section, we will deal with some methods commonly used to query an ArrayList.

Querying ArrayLists:

The following example demonstrates the usage of some more ArrayList methods:

//Other methods of ArrayList

package codingexamples;

import java.util.*;

 

public class ArrayListExample3 {

     public static void main(String[] args){

        ArrayList<String> list = new ArrayList<>();

        list.add(“Apple”);

        list.add(“Banana”);

        list.add(“Grapes”);

        list.add(1, “Watermelon”);

        list.add(“Apple”);       

        System.out.println(list);       

        String val = list.get(3);     //retrieve element at index 3

        System.out.println(val);

          int sz = list.size();

        System.out.println(sz);

       

        System.out.println(list.contains(“Banana”));

        System.out.println(list.contains(“String”));

        System.out.println(list.indexOf(“Apple”));

        System.out.println(list.indexOf(“String”));

        System.out.println(list.lastIndexOf(“Apple”));

     }

}

The output of the code is:

[Apple, Watermelon, Banana, Grapes, Apple]

Grapes

5

true

false

0

-1

4

The methods get() and size() used above are self-explanatory, which is evident from the first three lines of output (remember that index 3 is the fourth element). The method contains() returns true if the specified item is present in the list and false otherwise. In this case, the list contains “Banana” but does not contain “String”. And last, the indexOf() and lastIndexOf() methods return the indices of the first and the last occurrences of the specified object, respectively, or -1 if the object is not present. This is consistent with the above output.

The next section deals with a slightly more advanced concept related to ArrayLists.

Role of the equals() method in results of ArrayList methods:

The equals() method of class Object is inherited by all the classes in Java. But by default, it only checks whether the references of the invoking object and the method parameter are the same, or in other words, it returns true only if they refer to the same object. However, classes may override this method and define a new “equality” condition, which usually involves comparison of the instance variables of the objects.

Some of the methods in the ArrayList class, such as remove(), contains(), indexOf() and lastIndexOf() use the equals() method to check if an object is present in the list or not. Thus depending on whether the equals() method is overridden or not, the results of these methods may differ. This is demonstrated in the following code:

//Demonstrating effects of overriding equals() in classes used as the

//element type in an ArrayList

package codingexamples;

import java.util.*;

 

class Person1{

    private String name;

    Person1(String nm){name = nm;}

    public String getName(){return name;}

    //no equals() override

}

class Person2{

    private String name;

    Person2(String nm){name = nm;}

    public String getName(){return name;}

   

    //Override equals(), returns true if the names are equal

    public boolean equals(Object obj){

        if(obj instanceof Person2){

            Person2 other = (Person2)obj;

            boolean isEqual = this.name.equals(other.name);

            return isEqual;

        }

        else

            return false;

    }

   

}

public class ArrayListExample4 {

    public static void main(String[] args){

        ArrayList<Person1> list1 = new ArrayList<>();

        Person1 p1 = new Person1(“John”);

        Person1 p2 = new Person1(“Roger”);

        list1.add(p1);

        list1.add(p2);

       

        System.out.println(list1.contains(p2));                     //prints true

        System.out.println(list1.contains(new Person1(“Roger”)));   //prints false!

        list1.remove(new Person1(“John”));                      //doesn’t remove John!

       

        for(Person1 p : list1)

            System.out.print(p.getName() + “:”);

        System.out.println();

       

        ArrayList<Person2> list2 = new ArrayList<>();

        Person2 p3 = new Person2(“John”);

        Person2 p4 = new Person2(“Roger”);

        list2.add(p3);

        list2.add(p4);

       

        System.out.println(list2.contains(p4));                    //prints true

        System.out.println(list2.contains(new Person2(“Roger”)));  //also prints true!

        list2.remove(new Person2(“John”));                         //removes John

       

        for(Person2 p : list2)

            System.out.print(p.getName() + “:”);

        System.out.println();

    }

}

The output of the code, as it turns out, is:

true

false

John:Roger:

true

true

Roger:

The above code defines two almost identical classes, Person1 and Person2, both of which have a single instance variable, name. But Person1 does not override equals(), whereas Person2 does. In case it is tough to understand the code in the equals() override of class Person2, for now just remember that the new definition returns true if the names of the two Person2 objects are the same.

Now an ArrayList of Person1 objects is created and two Person1 objects with names John and Roger are added to it. If the ArrayList is queried whether it contains the object referenced by p2 (that is, ‘Roger’), it results in true. But if instead you pass a new object whose ‘name’ is also Roger to the contains() method, it results in false! Why? Because Person1 did not override equals(), and thus only object references were compared all along! Similarly, the next line demonstrates an unsuccessful (for the very same reason) attempt to remove ‘John’ from the list. This is demonstrated in the third line of output, which displays the ‘names’ of all the elements in the list.

The same things are done for another ArrayList of Person2 objects, and a significant change is observed in the output, only because Person2 overrode equals(), and so names instead of object references were compared! Thus the second call to contains() on the second list also produced true, and this time John was successfully removed from the list.

We have seen how to use ArrayLists in Java in this post – stay tuned for more technical posts!

ByBala Manikandan

ArrayLists: Dynamic Arrays in Java (Part 1)

Reading Time: 3 minutes

Before beginning this post, I would like to state that this post assumes some prior knowledge of Java (particularly arrays, classes and objects, and overriding)

The main limitation with arrays (groups of elements of the same datatype that are referenced by a common name) in Java is that they have a fixed size, and cannot shrink or grow in size. To overcome this, the ArrayList class can be used, which offers the functionality of a dynamic array. This class implements the List interface, which itself defines the methods used to manipulate ArrayLists. Both the class and the interface reside in the java.util package. This post deals with the functionality of various methods in the ArrayList class.

Adding elements to ArrayLists and Iterating through them:

The following example shows how to add elements to an ArrayList and iterate through them.

//Adding elements to an ArrayList and iterating through them

package codingexamples;

import java.util.*;

public class ArrayListExample1 {

    public static void main(String[] args){

        List<String> list = new ArrayList<>();    //works in Java 7 and above

        list.add(“Apple”);

        list.add(“Banana”);

        list.add(“Grapes”);

        list.add(1, “Watermelon”);              //insert “Watermelon” at position 1       

        System.out.println(list);               //prints out names of elements

        System.out.println();

               //iterate through elements using enhanced for loop

        for(String s : list)

            System.out.println(s);

            System.out.println();

            //iterate through elements using ListIterator

        ListIterator<String> itr = list.listIterator();

        while(itr.hasNext())

            System.out.println(itr.next());

        }   

}

The output of the code is:

[Apple, Watermelon, Banana, Grapes]

Apple

Watermelon

Banana

Grapes

Apple

Watermelon

Banana

Grapes

The first line marked in bold shows how to create an ArrayList. Note the use of angle brackets in this line. ArrayList can work with multiple object types (it is a generic collection), and the type to be stored (in this case String) must be specified in the angle brackets, making ArrayLists type safe. Also, as mentioned earlier, ArrayList implements the List interface, and all the methods commonly used with ArrayLists are defined in this interface itself. So, a List reference may be used to store an ArrayList object, as shown in this line. As of Java 7, the angle brackets on the right side of the ‘=’ sign can be left empty. So prior to Java 7, you would have had to write,

List<String> list = new ArrayList<String>();

The next few lines add elements to the ArrayList. While the elements “Apple”, “Banana” and “Grapes” are added to the end of the list each time (using the single argument add() method), the element “Watermelon” is inserted at position 1 (so that it is the second element, as the numbering starts from 0), using the two-argument add() method. The remaining elements are shifted ahead by one position when this happens.

In the next line, the list is passed to the println() method, which shows the elements of the ArrayList in order, in agreement with the add() method calls. And finally, the elements of the ArrayList are iterated through, using an enhanced ‘for’ loop and a ListIterator (observe the syntax when using ListIterator).

Modifying and Deleting Elements:

The following example shows how to modify and delete elements from an ArrayList:

//Modifying and deleting elements of an ArrayList

package codingexamples;

import java.util.*;

public class ArrayListExample2 {

    public static void main(String[] args){

        ArrayList<String> list = new ArrayList<>();

        list.add(“Apple”);

        list.add(“Banana”);

        list.add(“Grapes”);

        list.add(1, “Watermelon”);

        list.add(“Apple”);

       System.out.println(list);

     

        list.set(2, “Pomegranate”);      //modify element at index 2

       

        System.out.println(list);

       

        list.remove(2);                 //remove element at index 2

        list.remove(“Apple”);           //remove first occurrence of “Apple”

       

        System.out.println(list);

       

        list.clear();                   //clear the ArrayList

       

        System.out.println(list);

    }

}

The above code outputs:

[Apple, Watermelon, Banana, Grapes, Apple]
[Apple, Watermelon, Pomegranate, Grapes, Apple]
[Watermelon, Grapes, Apple]
[]

The first line of output shows the initial contents of the ArrayList. Then the set() method is used to modify the element at index 2 (that is the third element), which is reflected in the second line of output. After this, the element at index 2 and the element “Apple” are removed using the remove() method. But since the element “Apple” occurs twice in the ArrayList, only the first occurrence of the element is removed. The effect of this is shown in the third line of output. Finally the clear() method is used to clear the ArrayList, which is shown in the fourth line of output.

With this we come to the end of Part 1 of this post. For more information on ArrayLists, please do read Part 2 of this post which will be published on Friday, July 5th, 2019…