The El Gamal digital signature protocol was defined in 1985 ([4]). It is not a deterministic protocol, which means that for given message we can have more valid signatures. The verification function will accept as valid all these signatures. In the following, we utilize Alice, as the sender and Bob, as the receiver. Alice has the pair of keys (XA, YA) and Bob has the pair of keys (XB, YB).

Definition

We consider the public parameters are: p, g, YA. They are defined as follows.

We take p a big prime number for which the discrete logarithm problem is difficult in Zp.

We consider g ∈ Z∗p with order p-1 modulo p, being a prime factor for p-1.

Alice has the pair of keys (XA, YA). XA is the private key and YA is the public key.

XA ∈ Z∗p with XA does not divide p-1.

Alice’s public key is calculated function of Alice’s private key, YA = g^XA mod p

We provide here 4 examples for ElGamal digital signature.

Example 1

We consider p = 467; g = 2; XA = 127.

Now YA is calculated: YA = g^XA mod p = 2^127 mod 467 = 132.

So the Alice’s pair of keys is (127, 132).

We take message m= 100 and x = 213 for the signature of this message.

Here we notice that (213, 466)= 1

We calculate 213^−1 mod 466 = 431

Having these parameters, we can start to calculate the signature of Alice on the message m, which is represented by the pair (r, s).

r= g^x mod p = 2^213 mod 467 = 29

s= [m−(XA∗r)] / x mod p = (100-127*29) * 431 mod 466 = 51

Verification step:

g^m = Ya^r * r^s mod p

132^29 * 29^51 ≡ 189 (mod 467)

2^100 ≡ 189 (mod 467)

The verification confirms that the signature is valid.

Example 4

DSS - Digital Signature Standard

The Digital Signature Algorithm (DSA) is a Federal Information Processing Standard (FIPS) for digital signatures. It was proposed by the National Institute of Standards and Technology (NIST) in August 1991 for use in their Digital Signature Standard (DSS). DSA has been accepted and included in DSS in December 1994, supporting one modification: the message m has been replaced by the mark SHA1(m). Digital Signature Standard - DSS - is a variant of ElGamal digital signature protocol having the property that the length of the signature is reduced. The main difference between DSA and ElGamal digital signature is that DSA provides a digital signature of 320 bits on a message of 160 bits, using Zp where p has 512 bits, offering operations in a field with 2^160 elements.

You can visit the facebook page for the project to learn more and stay up to date with what is happening.

If you would like to contribute financially you can find the fundraising page here:

https://www.justgiving.com/company/microsoft-waterislife/

Below is a map showing the existing pump locations:

You can watch this inspiring video to find out what last year's CSS Malawi team got up to:

Thank you for your support!

1)      Search contract

The search contract lets your users search through your app’s content from anywhere in the system.

Using the Search charm helps you:

• Take advantage of muscle memory that users have built by using the Search charm in the system and in other apps
• Ensure that users have a consistent and predictable experience when they search and when they change search settings
• Make your app more visible by placing it at the top of the list of searchable apps if the user searches your app frequently

To have a great search experience, follow the guidelines for search
.

If the applications implements search contract:

Repeat the steps below:

1. When the target app is the current main app
2. When the target app is not started
3. When the target app is in snapped state.

How to make the test:

1. Test empty query string.
2. Start to enter a valid query string check for suggestions or recommendations and validate (e.g. No more than 5 suggestions, images, etc.)
3. Commit the query string.
   1. Review the search results and check if they are meaningful.
   2. Verify that filtering, query string highlighting, etc. is working as expected.
   3. Navigate back and forth from the search and other pages of the app
      1. Verify that the navigation works as expected.
         That is, you should be able to navigate back to the view from where you invoked the search contract.
      2. Verify that the search state is preserved.
      3. Verify that the state of other pages is preserved when the search contract is opened (e.g. in a mail app a started e-mail should be preserved).

Specific to snapped view look for issues with layout changes (results page)

2)      Share target contract 

Users will always have information they want to share.

If your app implements the share target contract, it will always be one swipe away for the user.

If you want to increase the usage for your app, and have scenarios that can consume data from other apps, implement the share target contract. 
Windows does most of the heavy lifting with sharing the data, you simply have to receive it and let the user access it within your app.


For more details, check the guidelines for sharing.

Check Manifest for declaration <ShareTarget>

Execute a share operation using the app as the target application and then ensure that:

1. The look and feel is kept between that target and source application. Target should display shared data without changing formatting and content received from source.
2. Navigation is implemented by the existing structure that supplies a default back-button
3. No light fly-outs are used to avoid user confusion because the Share UI already uses light dismiss.
4. Acknowledge user actions by letting the user know the system is responding for example through an inline message before closing the share pane.
5. The share action buttons should be on the right side of the screen so that users can reach them with their thumbs. These buttons allow the target to specify which type of data to consume. With exception of navigation button these should be the only ones present.
6. Data consumed should not be modified.

3)      Share source contract

An easy way to extend your application and connect it to any other application or service is to implement the share contract. Participating in the Share contract means that you don't have to write extra code or provide other developers with an SDK for your app just to share content.

You will be adding value and exposing it in the consistent, safe way that all Windows 8 users will expect.

For details on sharing, check the guidelines for sharing.

Install SDK sample target and check the below items:

• Check that only selected items are shared.
• When possible create links to online content for sharing.
• Ask if they using datapackage.datapackagepropertyset this will allow more a sharing experience.
  There are specific properties for example title, description, thumbnail, etc.
• Show errors inline
• Check that selections are preserved after a share operation.
• Ask what formats (dataset) they share and test target that it is visible.

Only share through the share charm.

4)      Leverages file pickers

A Metro style app can call a file picker window to let the user browse their system and pick files or folders for the app to operate on or to let the user save a file using a new name, file type, or location ("save as"). Apps can also use file pickers as an interface that enables them to provide other apps with files, a save location, or even file updates.

Leverage file pickers within your app if you want to interact with user data that is stored in files.

To learn more about file pickers and follow the guidelines for file pickers.

Ask if they use file picker and have demo. Appropriates uses cases are:

• Access user-specified files and folders.
• Add "save as" to your app.
• Provide files.
• Provide a save location.
• Provide real-time file updates.

Check for inappropriate use:

• Don't use a file picker to explore, consume, or manage file content.
  • 
    For example, a photo gallery app should provide a customized, dedicated page and UI that lets users organize and view picture files within the app. The app can then customize this UI to best suit the user’s needs. When the user wants to add files to the gallery, it would call the file picker to provide a page and UI that is specialized for that purpose.
  • 
    Don't use a file picker to save a file if a unique, user-specified file name or location is not needed.

by Michael Howard and Keith Brown

Security is a multidimensional issue. Security risks can come from anywhere. You could write bad error handling code or be too generous with permissions. You could forget what services are running on your server. You could accept all user input.

1. Trust User Input at Your Own Peril

2. Protect Against Buffer Overruns

3. Prevent Cross-site Scripting

4. Don't Require sa Permissions

5. Watch that Crypto Code!

6. Reduce Your Attack Profile

7. Employ the Principle of Least Privilege

8. Pay Attention to Failure Modes

9.Impersonation is Fragile

10. Write Apps that Non-admins Can Actually Use

1.     Trust User Input at Your Own Peril

Always remember one thing: "don't trust user input." If you always assume that data is well formed and good, then your troubles are about to begin. Most security vulnerabilities revolve around
the attacker providing malformed data to the server machine. Trusting that input is well formed can lead to buffer overruns, cross-site scripting attacks, SQL injection attacks, and more.

2. Protect Against Buffer Overruns

A buffer overrun occurs when the data provided by the attacker is bigger than what the application expects, and overflows into internal memory space. Buffer overruns are primarily a C/C++ issue. The overflow causes corruption of other data structures in memory, and this corruption can often lead to the attacker running malicious code. There are also buffer underflows and buffer overruns caused by array indexing mistakes, but they are less common. Take a look to the following source code example:

void DoSomething(char *cBuffSrc, DWORD cbBuffSrc) {

    char cBuffDest[32];

    memcpy(cBuffDest,cBuffSrc,cbBuffSrc);

}

If the data comes from an untrusted source and has not been validated, then the attacker (the untrusted source) could easily make cBuffSrc larger than cBuffDest, and also set cbBuffSrc to be larger than cBuffDest. When memcpy copies the data into cBuffDest, the return address from DoSomething is clobbered because cBuffDest is next to the return address on the function's
stack frame, and the attacker makes the code perform malicious operations.

The way to fix this is to distrust user input and not to believe any data held in cBuffSrc and cbBuffSrc:

void DoSomething(char *cBuffSrc, DWORD cbBuffSrc) {

    const DWORD cbBuffDest = 32;

    char cBuffDest[cbBuffDest];

#ifdef
_DEBUG

    memset(cBuffDest, 0x33, cbBuffSrc);

#endif

    memcpy(cBuffDest, cBuffSrc, min(cbBuffDest,
cbBuffSrc));

}

3. Prevent Cross-site Scripting

Cross-site scripting vulnerabilities are Web-specific issues and can compromise a client's data through a flaw in a single Web page. Imagine the following ASP.NET code fragment:

<script language=c#>

    Response.Write("Hello, " +
Request.QueryString("name"));

</script>

How many of you have seen code like this? You may be surprised to learn it's buggy! Normally, a user would access this code using a URL that looks like this:

https://explorationair.com/welcome.aspx?name=Michael

The C# code assumes that the data is always well formed and contains nothing more than a name. Attackers, however, abuse this code and provide script and HTML as the name. If you typed the following URL

https://northwindtraders.com/welcome.aspx?name=<script>alert('hi!');

</script>

you'd get a Web page that displays a dialog box, saying "hi!" "So what?" you say. Imagine that the attacker convinces a user to click on a link like this, but the querystring contains some really nasty script and HTML to get your cookie and post it to a site that the attacker owns; the attacker now has your private cookie information or worse.

Here is a way of avoiding this:

Regex r = new Regex(@"^[\w]{1,40}$");

       if
(r.Match(strName).Success) {

    // Cool! The string is ok

} else {

    // Not cool! Invalid string

}

This code uses a regular expression to verify that a string contains between 1 and 40 alphanumeric characters and nothing else. This is the only safe way to determine whether a value is correct.

The second defense is to HTML-encode all input when it is used as output. This will reduce dangerous HTML tags to more secure escape characters. You can escape any strings that might be a problem in ASP.NET with HttpServerUtility.HtmlEncode, or in ASP with Server.HTMLEncode.

4. Don't Require sa Permissions

The last kind of input trust attack we want to discuss is SQL injection. Many developers write code that takes input and uses that input to build SQL queries to communicate with a back-end data store, such as Microsoft® SQL Server™ or Oracle.

Take a look at the following code snippet:

void DoQuery(string Id) {

    SqlConnection sql=new
SqlConnection(@"data source=localhost;" +

            "user id=sa;password=password;");

    sql.Open();

    sqlstring= "SELECT hasshipped" +

            " FROM shipping WHERE
id='" + Id + "'";

    SqlCommand cmd = new
SqlCommand(sqlstring,sql);

This code is seriously flawed for three reasons:

-         the connection is made from the Web Service to SQL Server as the system administrator account, sa.

-         the clever use of "password" as the password for the sa account

-         the string concatenation that builds the SQL statement. If a user enters an ID of 1001, then you get the following SQL statement, which is perfectly valid and well formed.

SELECT
hasshipped FROM shipping WHERE id = '1001'

However, attackers are more creative than this. They would enter an ID of "'1001' DROP table shipping --", which would execute the following query:

SELECT
hasshipped FROM

shipping
WHERE id = '1001' 

DROP
table shipping -- ';

5. Watch that Crypto Code!

The most common mistake is homegrown encryption code, which is typically quite fragile and easy to break. Never create your own encryption code; you won't get it right. Don't think that just because you've created your own cryptographic algorithm people won't figure it out. Attackers have access to debuggers, and they have both the time and the knowledge to determine
exactly how these systems work—and often break them in a matter of hours. Rather, you should use the CryptoAPI for Win32® applications, and the System.Security.Cryptography namespace has a wealth of well-written and well-tested cryptographic algorithms.

6. Reduce Your Attack Profile

If a feature is not required by 90 percent of clients, then it should not be installed by default. Where services that you don't use are running, you don't pay attention to them and they can be exploited. If the feature is installed by default, then it should operate under the principle of least privilege. In other words, do not require the app to run with administrative rights if they
are not required.

7. Employ the Principle of Least Privilege

The operating system and the common language runtime (CLR) have a security policy for several reasons. The security policy is there to put walls around code so that intentional or (just as frequently) unintentional actions by users don't wreak havoc on the network. For instance, an attachment downloaded via e-mail and executed on Alice's machine is restricted to only accessing resources that Alice can access. If the attachment contains a Trojan horse, a good security policy will limit the damage it can do. When you design, build, and deploy server applications, you cannot assume that every request will come from a legitimate user. If a bad guy manages to send you a malformed request that causes your code to behave badly, you want every possible wall around your application to limit the damage. The principle of least privilege says that any given privilege should be granted to the least amount of code necessary, for the least amount of time necessary. In other words, at any given time, try to erect as many walls around your code as possible.

8. Pay Attention to Failure Modes

There are so many ways a piece of code can fail; it's just depressing thinking about it. Sadly, this is not a safe frame of mind. We need to pay much closer attention to failure modes in code. These bits of code are often written with little attention to detail and often go completely untested. Untested code often leads to security vulnerabilities. There are three things you can do to help alleviate this problem:

-         pay just as much attention to those little error handlers as you do your normal code. Think about the state of the system when your error-handling code is executing. Are you leaving the system in a valid and secure state?

-         once you write a function, step your debugger through it several times, ensuring that you hit every error handler. Note that even this technique may not uncover subtle timing errors. You may need to pass bad arguments to your function or adjust the state of the system in some way that causes your error handlers to execute

-         make sure your test suites force your functions to fail. Try to have test suites that exercise every line of code in your function. These can help you discover regression, especially if you automate your tests and run them after every build.

Be sure that if your code fails, it leaves the system in the most secure state possible.

9. Impersonation is Fragile

 Impersonation allows each thread in a process to run in a distinct security context, typically the client's security context. This is all well and good for simple gateways like the file system redirector. However, impersonation is often used in other, more complex applications. Take a Web application for instance. If you're writing a classic unmanaged ASP application, ISAPI extension, or an ASP.NET application which specifies

<identity impersonate='true'>

in its Web.config file, you are running in an environment with two different security contexts: you have a process token and a thread token, and generally speaking, the thread token will be used for access checks. Say you are writing an ISAPI application that runs inside the Web server process. Your thread token is likely IUSR_MACHINE, given that most requests are unauthenticated. But your process token is SYSTEM! Say your code is compromised by a bad guy via a buffer overflow exploit. Do you think the bad guy will be content with running as IUSR_MACHINE? No way. It's very likely that his attack code will call RevertToSelf to remove the impersonation token, hoping to elevate his privilege level. In this case, he'll succeed quite nicely. Another thing he can do is call CreateProcess. The token for that new process will be copied not from the impersonation token, but from the process token, so the new process runs as SYSTEM.

10. Write Apps that Non-admins Can Actually Use

 This really is a corollary of the principal of least privilege. Quit running as an administrator yourself. Check out Keith's Web site for more info on how developers can easily run as non-admins at https://www.develop.com/kbrown

Security Vulnerability

A security vulnerability is a weakness in a product that makes it impossible to prevent an attacker's malicious activities, even when the product is used correctly. Here are some possible malicious activities:

• Obtaining permissions on a computer that are higher than those of the user.
• Taking over the operation of a user's computer.
• Compromising data on a user's computer.

Note:
Never assume that your application will be run only in specific environments. Your application might be used in settings that you did not expect, especially when the application becomes popular. Assume instead that your code will run in hostile environments, and design, write, and test your code accordingly.

A secure product helps protect the following:

• Confidentiality, integrity, and availability of a customer's information.
• Integrity and availability of the processing resources under the control of the system owner or administrator.

"An effective attack method based on
  information exposed by search engines" by Antonios Gouglidis,
  University of Macedonia

"Eavesdropping on encrypted VoIP
  conversations: phrase spotting attack and defense approaches" by Vasily Prokopov, KTH Royal Institute
  of Technology

"Schnorr signcryption" by Laura Savu, University of
  Bucharest

"Security techniques for protecting data
  in the cloud" by Venkata Sravan Kumar
  Maddineni, Blekinge Institute of Technology

"Concept and development of a Facebook
  application to raise security and risk awareness regarding social
  engineering" by Iwan Gulenko,
  Technical University Munich

"Fingerprinting Tor" by Pablo Carballude González,
  University of Birmingham

"The state of industrial control systems
  security and national critical infrastructure protection" by Adesina Tinuade, Lulea
  University of Technology

"A mobile application for preventing
  online sexual exploitation attacks" by Dimitrios
  Michalopoulos, University of Macedonia

"Detecting flooding attacks using
  power" by Jean Tajer,
  University of Paris Descartes (via skype)

"Knowledge of information security
  issues – a senior management and educational perspective" by Sarfraz Iqbal, Lulea
  University of Technology

"Key factors and challenges for the
  successful development of the e-security aspect of an organization’s security
  policy: an IS design and e-services approach" by Ali Mohammad Padyab, Lulea
  University of Technology

"Design of a security protocol for the
  mTAN procedure" by Daniel Zelle,
  University of Paderborn

Panel Discussion: "The Future of the Internet"

An effective attack method based on information exposed by search engines

Web 2.0 consists one of the most emergent technologies of the World Wide Web. This type of technologies can be made available to consumers through a series of web services. Nevertheless, as a relative new approach, it is prone to various security issues. One of these is the potential to use web services provided by search engines such as Google’s and Microsoft’s Bing, in order to identify and attack vulnerable systems. In this paper, we describe a 3-step methodology that can be fully automated in order to deploy massive attacks against vulnerable systems. The methodology described takes advantage of the Google Hacking technique and extends it with two more steps that of information manipulation and the deployment of an exploit. An implementation of a python script demonstrates the applicability and the efficiency of the proposed attack. A real-world example, taking advantage of the JBoss JMX Management Console faulty configuration, indicates the extension of the problem. We anticipate this initiative to help in the identification of similar attack methods and the development of newly and more effective countermeasures against this type of attack methods.

Eavesdropping on encrypted VoIP conversations: phrase spotting attack and defense approaches

Voice over IP (VoIP) has recently become an important part of our day to day life. As VoIP technology evolves, matures and becomes increasingly popular, it also gains the attention of attackers who wish to eavesdrop on VoIP conversations.

In this paper we first describe an attack that can identify phrases spoken within encrypted VoIP calls under certain (but commonly occurring) circumstances. Then we propose and analyze several methods to protect against phrase spotting attack. Finally, we introduce a model of a voice coder (vocoder) protected from this type of attack.

Schnorr signcryption

This article presents a new signcryption scheme which is based on the Schnorr digital signature algorithm. The new scheme represents my personal contribution to signcryption area. I have implemented the algorithm in a program and here are provided the steps of the algorithm, the results and some examples. The paper also contains the presentation of the original Signcryption scheme, based on ElGamal digital signature and discusses the practical applications of Signcryption in real life. The purpose of the study is to combine the public key encryption with Schnor digital signature in order to obtain less computational and communicational costs. Signcryption primitive is a better approach then Encrypt-then-Sign or Sign-then-Encrypt methods regarding the costs. All these algorithms offer the possibility to transmit a message over an insecure channel providing both authenticity and confidentiality.

Concept and development of a Facebook application to raise security and risk awareness regarding social engineering

Social engineering, in the context of security, is understood to mean the art of manipulating people into performing actions or divulging confidential information. While it is similar to a confidence trick or simple fraud, the term typically applies to trickery or deception for the purpose of information gathering, fraud, or computer system access; in most cases the attacker never comes face-to-face with the victims.

"Social engineering" as an act of psychological manipulation was popularized by hacker-turned-consultant Kevin Mitnick. The term had previously been associated with the social sciences, but its usage has caught on among computer professionals

Fingerprinting Tor

Website fingerprinting is the act of recognizing web traffic through surveillance despite the use of encryption or anonymizing software. The general idea is to leverage the fact that many web sites have specific fixed request patterns and response byte counts that are known beforehand. This information can be used to recognize your web traffic despite attempts at encryption or tunneling. Websites that have an abundance of static content and a fixed request structure tend to be  vulnerable to this type of surveillance. Unfortunately, there is enough static content on most websites for this to be the case.

Detecting flooding attacks using power

A UDP flood attack is a denial-of-service (DoS) attack using the User Datagram Protocol (UDP), a sessionless/connectionless computer networking protocol.

Using UDP for denial-of-service attacks is not as straightfforward as with the Transmission Control Protocol (TCP). However, a UDP flood attack can be initiated by sending a large number of UDP packets to random ports on a remote host. As a result, the distant host will:

• Check for the application listening at that port;
• See that no application listens at that port;
• Reply with an ICMP Destination Unreachable packet.

Thus, for a large number of UDP packets, the victimized system will be forced into sending many ICMP packets, eventually leading it to be unreachable by other clients. The attacker may also spoof the IP address of the UDP packets, ensuring that the excessive ICMP return packets do not reach him, and anonymizing the attacker's network location(s).

This attack can be managed by deploying firewalls at key points in a network to filter out unwanted network traffic. The potential victim never receives and never responds to the malicious UDP packets because the firewall stops them.

Knowledge of information security issues – a senior management and educational perspective

Information security means protecting information and information systems from unauthorized access, use, disclosure, disruption, modification, perusal, inspection, recording or destruction.

The terms information security, computer security and information assurance are frequently used interchangeably. These fields are interrelated often and share the common goals of protecting the confidentiality, integrity and availability of information; however, there are some subtle differences between them.

These differences lie primarily in the approach to the subject, the methodologies used, and the areas of concentration. Information security is concerned with the confidentiality, integrity and availability of data regardless of the form the data may take: electronic, print, or other forms. Computer security can focus on ensuring the availability and correct operation of a computer system without concern for the information stored or processed by the computer. Information assurance focuses on the reasons for assurance that information is protected, and is thus reasoning about information security.

Governments, military, corporations, financial institutions, hospitals, and private businesses amass a great deal of confidential information about their employees, customers, products, research, and financial status. Most of this information is now collected, processed and stored on electronic computers and transmitted across networks to other computers.

Key factors and challenges for the successful development of the e-security aspect of an organization’s security policy: an IS design and e-services approach

Information security means protecting information and information systems from unauthorized access, use, disclosure, disruption, modification, perusal, inspection, recording or destruction.

The terms information security, computer security and information assurance are frequently used interchangeably. These fields are interrelated often and share the common goals of protecting the confidentiality, integrity and availability of information; however, there are some subtle differences between them.

These differences lie primarily in the approach to the subject, the methodologies used, and the areas of concentration. Information security is concerned with the confidentiality, integrity and availability of data regardless of the form the data may take: electronic, print, or other forms. Computer security can focus on ensuring the availability and correct operation of a computer system without concern for the information stored or processed by the computer. Information assurance focuses on the reasons for assurance that information is protected, and is thus reasoning about information security.

Design of a security protocol for the mTAN procedure

A Transaction authentication number, TAN or T.A.N. is used by some online banking services as a form of single use one-time passwords to authorize financial transactions. TANs are a second layer of security above and beyond the traditional single-password authentication.

TANs are believed to provide additional security because they act as a form of two-factor authentication. Should the physical document or token containing the TANs be stolen, it will be of little use without the password; conversely, if the login data are obtained, no transactions can be performed without a valid TAN.

The original signcryption scheme that has been introduced by Youliang Zheng in 1997 is created on a derivation of ElGamal digital signature standard, combined with a public key encryption scheme. 

Based on discrete algorithm problem, ElGamal Signcryption cost is:

Here is the detailed presentation of the fifth algorithms that make up the ElGamal signcryption scheme.

1)Setup

Signcryption parameters:

p = a large prime number, public to all;  q = a large prime factor of p-1, public to all;
g = an integer with order q modulo p, in [1,… , p-1], public to all

hash = a one-way hash function;

KH = a keyed one-way hash function = KHk(m) = hash(k, m)

(E, D) = the algorithms which are used for encryption and decryption of a private key cipher.

Alice sends a message to Bob.

2)KeyGen sender

Alice has the pair of keys (Xa, Ya):

Xa = Alice’s private key, chosen randomly from [1, .., q-1];
Ya=Alice’s public key =  mod p

3)KeyGen receiver

Bob has the pair of keys(Xb, Yb):

Xb = Bob’s private key, chosen randomly from [1, .., q-1];
Yb = Bob’s public key =  mod p.

4)Signcryption

In order to signcrypt a message m to Bob, Alice has to accomplish the following operations:

Calculate

Split k in k1 and k2 of appropriate length.

Calculate r = KHk2(m) = hash(k2, m)

Calculate s = x/(r+Xa) mod q, if SDSS1 is used

Calculate s = x/(1+Xa ∙ r) mod q, if SDSS2 is used

Calculate c = Ek1(m) = the encryption of the message m with the key k1.

Alice sends to Bob the values (r, s, c).

5)Unsigncryption

In order to unsigncrypt a message from Alice, Bob has to accomplish the following operations:

Calculate k using r, s, g, p, Ya and Xb

Split k in k1 and k2 of appropriate length.

Calculate m using the decryption algorithm m = Dk1(c).

Accept m as a valid message only if KHk2(m) = r.

ECC Signcryption

 The first signcryption scheme was introduced by Yuliang Zheng in 1997. Zheng also proposed an elliptic curve-based signcryption scheme that saves 58% of computational and 40% of communication costs when it is compared with the traditional elliptic curve-based signature-then-encryption schemes .

The elliptic curve-based schemes are usually based on difficulty of Elliptic Curve Discrete Logarithm Problem (ECDLP) that is computationally infeasible under certain circumstances. The elliptic curve-based systems can attain to a desired security level with significantly smaller keys than those of required by their exponential-based counterparts. This can enhance the speed and leads to efficient use of power, bandwidth, and storage that are the basic limitations of resource-constrained devices

SECURITY MODELS FOR SIGNCRYPTION

1) TWO-USERS SECURITY MODEL

In the symmetric setting, there is only one specific pair of users who

(1) share a single key;

(2) trust each other;

(3) “know who they are”;

(4) only care about being protected from “the rest of the world.”

  2) MULTI-USER SECURITY MODEL

A central difference between the multi-user model and the two-user models is the extra power of the adversary. In the multi-user model, the attacker may choose receiver (resp. sender) public keys when accessing the attacked users’ signcryption (resp. unsigncryption) oracles. For signcryption schemes that share some functionality between the signature and the encryption components, such as are the case for Zheng’s Signcryption scheme and Schnorr Signcryption scheme, the extra power of the adversary in the multi-user model may be much more significant, and a careful case-by-case analysis is required to establish security of such schemes in the multi-user model.

As in the two-user setting, the multi-user setting also has two types of models depending on the identity of the attacker: an insider model and an outsider model.

Practical implementation of Signcryption in real life

The shared secret key between the parties makes possible an unlimited number of applications. Among these applications, one can first think of the following three:

•secure and authenticated key establishment,

      A number of signcryption-based security protocols have been proposed for aforementioned networks and similar environments. These include:

•secure ATM networks,

•secure routing in mobile ad hoc networks,

•secure voice over IP (VoIP) solutions,

•encrypted email authentication by firewalls,

•secure message transmission by proxy, and

•mobile grid web services.

There are also various applications of signcryption in electronic commerce, where its security properties are very useful. Analyzing this security scheme from an application-oriented point of view, can be observed that a great amount of electronic commerce can take advantage of signcryption to provide efficient security solutions in the following areas:

•electronic toll collection system,

•authenticated and secured transactions with smart cards.

How we protect now: signatures +

Signcryption

Signcryption is the primitive that combines public key encryption and digital signature in a single logical step for obtaining less computational and communicational cost.

Data confidentiality and data integrity are two of the most important functions of modern cryptography. Confidentiality can be achieved using encryption algorithms or ciphers, whereas integrity can be provided by the use of authentication techniques. Encryption algorithms fall into one of two broad groups:  private key encryption and public key encryption. Likewise, authentication techniques can be categorized by private key authentication algorithms and public key digital signatures.

Signcryption is  the primitive that has been proposed by Youliang Zheng in 1997 and combines public key encryption with digital signature in a single logical step, obtaining a less cost for both communication and computation.

Signcryption has the intention that the primitive should satisfy the condition “Cost(Signature & Encryption)<< Cost(Signature) +Cost(Encryption).”

This inequality can be interpreted in a number of ways:

• A signcryption scheme should be more computationally efficient than a native combination of public-key encryption and digital signatures.

• A signcryption scheme should produce a signcryption “ciphertext” which is shorter than a naive combination of a public-key encryption ciphertext and a digital signature.

• A signcryption scheme should provide greater security guarantees and/or  greater functionality than a native combination of public-key encryption and digital signatures.

A signcryption scheme typically consists of five algorithms, Setup, KeyGenS, KeyGenR, Signcrypt, Unsigncrypt:

1) Setup - takes as input a security parameter 1^ k and outputs any common parameters param required by the signcryption schemes. This may include the security parameter 1^ k , the description of a group G and a generator g for that group,     choices for hash functions or symmetric encryption schemes, etc.

2) Key Generation S(Gen) - generates a pair of keys for the sender 

3) KeyGeneration R(Gen) - generates a pair of keys for the receiver

4) Signcryption (SC) - is a probabilistic algorithm

5) Unsigncryption (USC) - is a deterministic algorithm.

A public key encryption scheme consists of three polynomial-time algorithms (EncKeyGen, Encrypt, Decrypt).

EncKeyGen - Key generation is a probabilistic algorithm that takes as input a security parameter 1^ k and outputs a key pair (skenc, pkenc), written (skenc, pkenc)R←EncKeyGen(1^k ). The public encryption key pkenc is widely distributed, while the private decryption key skenc should be kept secret. The public key defines a message m ∈ M and a ciphertext ∈ C.

Encrypt - Encryption is a probabilistic algorithm that takes a message m ∈ M and the public key pkenc as input and outputs a ciphertext C ∈ C, written C ←Encrypt(pkenc,m)

Decrypt  - Decryption is a deterministic algorithm that takes a ciphertext C ∈ C and the private key skenc as input and outputs either a message m ∈M or the failure symbol ⊥, written m ← Decrypt(skenc,C).

A signcryption scheme is a combination between a public key encryption algorithm and a digital signature scheme.

• A whole new generation of more organized and more malevolent malware writers
• Malware attacks targeting information as well as for financial gain
• Information becoming the target of the new breed of cybercriminals and another source of income for those already in the game
• Steal Everything! The emergence of Spyware 2.0, a new class of malware that steals users' personal data (identity theft) plus other type of data it can find. Spyware 2.0 becoming a popular tool for both new and old players alike
• An increasing number of attacks on corporate users by traditional cybercriminals and the gradual decline in direct attacks on everyday users
• Vulnerabilities remaining the principal method of carrying out attacks and a significant increase in the scope and speed with which they are used

Scareware

Scareware for Mac

https://www.kaspersky.com/educational-events/it_security_conference_2012

Conference Topics:

1. Technical nomination

2. Trends in Anti-Spam Development – Techniques, Methods in the “Spam Arms Race” and new Innovations
3. Dangers of an increasingly Networked World
4. 'In the Cloud' Security
5. Future Technologies for Detecting and Combating Malware (e.g. artificial intelligence, fuzzy systems, p2p networks)

1. Social, economic and legal nomination

2. Emerging Threats (e.g. social network security, embedded systems security, mobile security, online banking security)
3. Challenges and Opportunities for IT-Security Companies within the next 10 years
4. Impact of technologies on Data Protection, Copy and Intellectual Property Rights and Jurisdiction
5. Education in IT Security - Trends and Questions

The Malware Threat Landscape 2012 & Beyond

Malicious software

Viruses

•Spread from file to file

Worms

•Spread from computer to computer

Trojans

•No self-replication

Malicious tools

•Used by malware authors

•e.g. Packers, constructors, exploits

How and where to detect malware

On-Site (Local Anti-Virus Engine)

All round protection

CPU intensive

Requires frequent updates

Cloud

No updates

Fast detection

Able to use in-house technologies without revealing it (better protection)

No protection without Internet connectivity

Problems with latency

 Optimum solution:Hybrid (on site + cloud)

Top countries with harmful hostings by Web Anti-Virus

Top countries with the highest share of attacks on users’ computers (Web-Antivirus)

Nature of Threats

Drive-by downloads

Recipe

1.Find a vulnerable server

2.Obfuscate your code to prevent easy analysis

3.Insert your script onto the website

4.Redirect users of the infected website to your malicious website

5.Download malware to victims machine

Botnet – robot (zombie) network

•A number of comprised machines controlled remotely

Conclusion thoughts of the conference

Cybercrime is here to stay

So we need to find ways to mitigate the risks

‘Follow me’ security

All devices

All types of threat

Manageable

We need to foster a culture of security awareness. Education of security threats, policies and safe surfing habits

But the publishing portal’s navigation does not enter newly created nodes into database unless we do some activity on the navigation provider via  _layouts\AreaNavigationSettings.aspx.

I also tried to move/hide the nodes before fetching it using a similar console application ; Just to see if I get those newly added nodes. But I don’t and it’s because when I do  SPNavigationNode.MoveToLast I am sorting or moving the database nodes and not the one which are there in Memory which will trigger entries of new nodes in database.

Workaround

The workaround to this issue is to use PortalSiteMapProvider class, get the provider that is being used and iterate, you will get all nodes, sorted the way you see in the Quick Launch

I have also attached this same code (.cs) in the attachment to this email as well.

The only issue here is that this code will only run in web context (httpcontext), so if you want to use in an ASPX page, you can create a user control or a webpart and add it in a page.

If you have a standalone tool which needs to access navigation nodes, then I suppose you will have to put this code in a webservice and consume it.

Here is the code

try

           {

                PortalSiteMapProvider sitemapprovider = (PortalSiteMapProvider)SiteMap.Providers["CurrentNavSiteMapProvider"];

                SiteMapNode rootNode = sitemapprovider.CurrentNode;

                writer.WriteLine(rootNode.Title + "<br>");

                if (rootNode.ChildNodes.Count > 0)

                {

                    foreach (SiteMapNode childNode in rootNode.ChildNodes)

                    {

                        writer.WriteLine(" - " + childNode.Title + "<br>");

                    }

                }

            }

            catch (Exception e)

            {

                writer.WriteLine("Error: " + e.Message + System.Environment.NewLine +  "Stack trace: " + e.StackTrace);

            }