The terms algorithm and cipher describe the formula or process used to perform encryption.

4.2.2 Public-Key Cryptography

The symmetric key algorithms are quite efficient, but the key distribution is difficult to IoT end devices. The key distribution requires a secure connection between the key distribution sever and the IoT nodes. PKC and asymmetric cryptography are two effective ways of providing confidentiality and authentication. In contrast to the symmetric cryptography, the PKC is based on mathematically hard problem to solve, whereas hard in this context refers to the complexity of calculation. The public-key encryption is based on “trapdoor” functions, which are easy to compute, but hard to reverse without additional information. The RSA is a widely used public-key algorithm, in which the hard problem is finding the prime factors of a composite number. In PKC cryptosystem, generally in a key pair, the public key and the private key, the public key is made accessible to the public and the private key is kept at a safe place. The public key is generally used in two ways.

Public-key encryption, in which one is capable to encrypt a message with the public key of an entity, where only the entity with the corresponding private key is capable of decrypting the cipher text.

Digital signatures, in which a cipher text generated with the private key can be decrypted by anyone who has the public key. This verification proves that the sender had access to the private key and therefore is likely to be the person associated with the public key.

In PKC system, public/private key pairs can be easily generated for encryption and decryption. The security strength in a PKC system lies in how difficult to determine a properly generated private key from its public key. In this case, the length of private key is important for avoiding brute-force attacks.

The RSA is one of the first practical public-key cryptosystems, which is based on the practical difficulty of factoring the product of two large prime numbers. If the public key is large enough, only the one knowing the prime numbers can feasibly decode the message. The RSA is a relative slow algorithm for encryption however it is commonly used to pass encrypted shared keys for symmetric key cryptography. Since RSA encryption is an expensive operation, in IoT it is rather used in combination with symmetric cryptography. The shared symmetric key is encrypted with RSA; the security of encryption in general is dependent on the length of the key. For RSA, a key length of 1024 bits (128 bytes) is required, to have an equivalent security level of symmetric key cryptography with a key length of 128 bit (16 bytes). The large key size of RSA will cause expensive computation costs.

The ECC is an alternative to common PKC because of the resistance against powerful index-calculus attacks. The ECC allows efficient implementation due to a significant smaller bit size of the operands over resource-constrained environment. ECC is another public-key cryptography approach that works based on elliptic curves over finite fields. ECC’s smaller key size is 256 as shown in Table 4.2. It is more efficient than RSA and it is more suitable for resource-limited devices in IoT. The basic idea of ECC is the general assumption that the elliptic curve discrete logarithm problem is infeasible or at least not solvable in a reasonable time.

Table 4.2. Key Size for Symmetric Key, RSA, and ECC

Cryptographic Algorithms

In cryptography, the strength of a transaction is based on the key. In general, the longer the key, the stronger it is. Many different systems use the same cryptographic algorithm, but they all use different keys. It's important that you keep the key safe and confidential. If the key gets lost, you will no longer be able to decrypt data that was encrypted with it. If someone else comes in possession of the key, then he or she will be able to decrypt your encrypted data.

There is a specific type of cryptographic vulnerability related to cryptographic keys. It is called weak keys. All cryptographic algorithms are based on some sort of mathematical function. Many times, mathematical functions can have numbers or series of numbers that cause the function to behave improperly. In cryptography, this number or series of numbers is called a weak key. When cryptographic algorithms are designed, the creators try to reduce or eliminate the possible number of weak keys. But, they are not always successful.

There are two general types of cryptographic ciphers: block ciphers and stream ciphers. Block ciphers encrypt data one fixed block of data at a time. The length of this block of data is called the block size. With block ciphers, the encrypted block of data will generally be the same length as the unencrypted block of data. Stream ciphers generally encrypt data one bit at a time. Stream ciphers generate and use a key stream for encryption, not just a single key. Stream ciphers are generally much faster than block ciphers. This is due to the simple mathematical formulas generally used with stream ciphers.

Introduction

So far, we have been examining symmetric key algorithms that rely solely on secret keys for security. Now we are going to explore the realm of public key cryptography, but before we can do this, we have a significant piece of mathematics to cover.

Most standard public key algorithms are based on problems that are hard to solve in general. For example, the RSA algorithm is (loosely speaking) as secure as factoring is hard. That is, if factoring is hard, breaking RSA is, too (in practice). Similarly, elliptic curve algorithms are as hard to break as inverting point multiplication on the given curve.

In both cases, the “problem” becomes harder as you increase the size of the problem. In the case of RSA, as you increase the composite (public key), factoring becomes harder. Similarly, as you increase the order of the elliptic curve (do not worry if you do not know what that means at this point), the difficulty of inverting point multiplication increases.

To accommodate these larger parameters, we must deploy algorithms known collectively as BigNum algorithms.

Introduction

So far, we have been discussing symmetric key algorithms such as AES, HMAC, CMAC, GCM, and CCM. These algorithms are known as symmetric (or shared secret) algorithms, since all parties share the same key values. Revealing this key would compromise the security of the system. This means we have been assuming that we somehow shared a key, and now we are going to answer the how part.

Public key algorithms, also known as asymmetric key algorithms, are used (primarily) to solve two problems that symmetric key algorithms cannot: key distribution and nonrepudiation. The first helps solve privacy problems, and the latter helps solve authenticity problems.

Public key algorithms accomplish these goals by operating asymmetrically; that is, a key is split into two corresponding parts, a public key and a private key. The public key is so named as it is secure to give out publicly to all those who ask for it. The public key enables people to encrypt messages and verify signatures. The private key is so named as it must remain private and cannot be given out. The private key is typically owned by a single person or device in most circumstances, but could technically be shared among a trusted set of parties. The private key allows for decrypting messages and the generation of signatures.

The first publicly disclosed public key algorithm was the Diffie-Hellman key exchange, which allowed, at least initially, only for key distribution between known parties. It was extended by ElGamal to a full encrypt and signature public key scheme, and is used for ECC encryption, as we will see shortly. Shortly after Diffie-Hellman was published, another algorithm known as RSA (Rivest Shamir Adleman) was publicly presented. RSA allowed for both encryption and signatures while using half of the bandwidth as ElGamal. Subsequently, RSA became standardized in various forms.

Later, in the 1980s, elliptic curves were proposed as an abelian group over which ElGamal encryption and DSA (variant of ElGamal) could be performed, and throughout the 1990s and 2000s, various algorithms were proposed that make elliptic curve cryptography an attractive alternative to RSA and ElGamal.

For the purposes of this text, we will discuss PKCS #1 standard RSA and ANSI standard ECC cryptography. They represent two of the three standard algorithms specified by NIST for public key cryptography, and in general are representative of the commercial sector demands.

RSA

The three algorithms we have looked at so far are all symmetric-key algorithms that are very useful if you have a good way to exchange keys with the person or machine with which you want to communicate. In some cases, a physical transfer of the key may be possible and appropriate, but more often, an electronic means of key delivery is more applicable. Today, in most cases, this method is RSA. Developed and patented by Ronald Rivest, Adi Shamir, and Leonard Adleman in 1978, RSA is the most well-known and probably most useful public-key algorithm. One of the most useful properties of RSA is that it can be used both for the basic public-key operation (I send you my public-key so you can encrypt a message to send back to me), and for authentication (I encrypt a message with my private key which you can verify came from me using my known public-key). This property makes RSA especially useful for protocols that utilize both a public-key operation and authentication, like SSL.

RSA is an elegantly simple algorithm with some extremely complex math behind it. Essentially, RSA consists of a function that utilizes some unique properties of large prime numbers and modular mathematics. The key generation for RSA involves selecting two very large prime numbers and multiplying them together. The trick is that if you know the prime factors used to generate the key then the RSA encryption function is simple to reverse (thereby decrypting an encrypted message). If you don't know those factors, then you have to find them by factoring a REALLY large number into its component prime factors, a process that takes an extremely long time using today's math and technology. It is possible that we may discover a fast way to factor large numbers in the future, and this would be a very big problem, since it would render RSA completely useless. This prime factoring can be considered similar to the brute-force search required for the naïve attack on symmetric algorithms. However, factoring a number is inherently easier than searching through all possible symmetric keys represented by a number of the same size. It is for this reason that symmetric keys are often 128 bits long, but a similarly-secure RSA key will be 1024 or 2048 bits long. Unfortunately, these large numbers are hard to deal with, even on a computer, so RSA is significantly slower than any of the symmetric algorithms we have looked at.

RSA is too slow to be generally useful, but since it does have specific useful properties, it is usually used along with a faster symmetric algorithm, usually to exchange symmetric keys. For embedded systems, the performance of RSA is especially problematic, since an RSA operation on even a moderate-sized key (1024-bits is considered moderate as of right now) can take many seconds on slower processors. For some applications, this might be OK, since the system may not need super speedy response times. For other applications, such as web servers, this is definitely a problem, as the typical user will not wait 30–40 seconds for a webpage to even start loading. For this reason RSA should be used with some type of hardware acceleration if at all possible. Fortunately, like AES, there are a number of products available that either implement RSA entirely in hardware or provide some type of acceleration for software implementations. The primary part of RSA that benefits from acceleration is the modular math—literally millions of operations are done in a typical RSA operation and any improvement in their speed will result in a significant improvement in performance.

RSA is an extremely useful algorithm that is employed in thousands of applications. We will look more at how RSA is implemented, and what we can do to alleviate the performance bottleneck, when we look at SSL, and again when we look at the case studies later on.

Encryption Algorithm Selection

Algorithms can be generically categorized as either symmetric or asymmetric. A symmetric-key algorithm, better known as a shared secret, uses a single key for encryption and decryption. This is suitable when two parties have established a relationship in advance. Table 15.2 shows some of the algorithms that can be used in a symmetric scenario.

Table 15.2. Symmetric Algorithms

Asymmetric algorithms are better known as public/private-key. This encryption is best used between two parties who have no prior knowledge of each other but want to exchange data securely. Unlike symmetric algorithms, asymmetric algorithms use two different cryptographic keys to encrypt and decrypt plain text. The two keys have a mathematical relationship. A message encrypted by the algorithm using one key can be decrypted by the same algorithm using the other key. Some asymmetric algorithms have the property that one key is deducible from the other. These algorithms are typically incorporated into public/private-key algorithms commonly used by certificate providers.

Encryption mechanisms typically use various algorithms for their routines. Listed below are some of the algorithms that can be used to develop your own encryption mechanism, along with their relative strengths and weaknesses. Many other encryption algorithms can be part of your toolkit but are not in widespread usage. If you want to go down this path, we recommend Applied Cryptography, by Bruce Schneier (Wiley, 1996).

Symmetric key algorithms

Some of the cryptographic algorithms that are more recognizable to the general public are symmetric key algorithms. Several of these, such as DES, 3DES, and AES, are or have been in regular use by the US government and others as standard algorithms for protecting highly sensitive data.

DES first came into use in 1976 in the United States and has since been used by a variety of parties globally. DES is a block cipher based on symmetric key cryptography and uses a 56-bit key. Although DES was considered to be very secure for some period of time, it is no longer considered to be so. In 1999, a distributed computing project was launched to break a DES key by testing every possible key in the entire keyspace, and the project succeeded in doing so in a little more than 22 h. This weakness brought about by the short key length was compensated for a period of time through the use of 3DES (pronounced triple DES), which is simply DES used to encrypt each block three times, each time with a different key. DES can operate in several different block modes, including Cipher Block Chaining (CBC), Electronic CodeBook (ECB), Cipher Feedback (CFB), Output Feedback (OFB), and Counter Mode (CTR). Each mode changes the way encryption functions and the way errors are handled.

AES is a set of symmetric block ciphers endorsed by the US government through NIST, and now used by a variety of other organizations, and is the replacement for DES as the standard encryption algorithm for the US federal government. AES uses three different ciphers: one with a 128-bit key, one with a 192-bit key, and one with a 256-bit key, all having a block length of 128 bits. A variety of attacks have been attempted against AES, most of them against encryption using the 128-bit key, and most of them unsuccessful, partially successful, or questionable altogether. At the time of this writing, the US government still considers AES to be secure. AES shares the same block modes that DES uses and also includes other modes such as XEX-based Tweaked CodeBook (TCB) mode.

There are a large number of other well-known symmetric block ciphers, including Twofish, Serpent, Blowfish, CAST5, RC6, and IDEA, as well as stream ciphers, such as RC4, ORYX, and SEAL.

Public Key Algorithms

Although these algorithms are based on asymmetric key cryptography and are more resource intensive than symmetric key algorithms, they offer better security services, which are much needed and highly advantageous in WSN. As a result, there is motivation to pursue research in developing secure and efficient key-distribution mechanisms suitable in a resource-constraint environment such as WSN. Most of the implementations use Rivest, Shamir, Adleman (RSA) or elliptic curve cryptography (ECC) [12,20].

For example, TinyPK uses the Diffie-Hellman key-exchange technique for key agreement between nodes and is based on the legacy RSA cryptosystem. The main motive of this protocol is to facilitate secure communication between external users and the sensor networks. The external user’s identity is established by a CA, where his or her public key is signed by the CA’s private key.

Considering the state of the art in large-number factorization, key-size values are usually set to 1024 bits in RSA as lower values are considerably vulnerable to security attacks. In addition, the public key exponent e is set to 3, and all the resource-intensive operations are carried out on external servers. In this model, resource-abundant devices bear the burden of RSA private key operations, and, hence, the sensor nodes maintain higher energy levels during operations.

5.4 Protecting One-Way Telemetry

A one-way telemetry link is an interesting reversal of the scenario described in the previous section. The difference between telemetry information and control information is that telemetry frequently remains valuable long after it's collected, which control information (generally) does not. In this case, we may be relying on the cryptosystem to provide both authentication (verifying that the telemetry we're receiving is actually coming from the source it's supposed to be coming from) and encryption (making sure that other people can't use our collected data). An example of this sort of application might be stock control using handheld wireless transmitters. You want to be sure that only authorized personnel can check stock out of inventory; you also want to avoid broadcasting the exact contents of your warehouse to everyone in the neighborhood.

Again, let's look at our requirements. Once more, we have a relatively low-powered handheld transmitter, but it's feasible that it could be a reasonably speedy 32-bit part, perhaps an ARM7 microcontroller with an LCD controller on-chip. Let's assume, however, that it is too slow to implement an asymmetric algorithm. It is probably safe to assume also that we can collect the transmitters at the end of every day and perform some physical link to them. Our aim, for the sake of argument, is to prevent the competitor across the road from intercepting our shipment orders and deducing which products we're selling briskly. (We're in a cut-throat business. If our competitor finds out that our left-handed widgets are selling quickly, he might choose to undercut our price, even if it means a net loss to him, and drive us out of the market. Or if he sees that we're using a huge quantity of some particular part, maybe he'll try to buy up stocks of that part and raise the market price to damage our operations). A small amount of data leakage is acceptable.

We can satisfy all our requirements with a system that comprises the following features:

The transmitters use a symmetric-key algorithm with a key width that's reasonably hard to crack with commercial-grade computational power.

Each transmitter has a serial number that can be read out using a physical connection to the unit.

Employees are instructed to put the transmitters onto charge/reprogramming stations after every shift.

Each unit is loaded with a new random key when it is put on the charge station. The station interrogates the unit to find out its serial number, and informs the central computer (over a secure, wired link) of the serial number and the assigned key. No mechanism is provided for the current key to be read out of the unit.

Every transmission from the unit is encrypted with the key assigned for this specific unit for this shift. Since this is constantly changing, if our attacker happens to break a particular key, he can only recover one shift's worth of messages from one handheld unit.

The stock-control computer is off-site. All stock add/remove requests are forwarded to the stock-control computer verbatim; that is, the local receiver hardware does not remember assigned keys, and there is no on-site information to decrypt those on-air messages.

Note that I haven't explicitly discussed the cryptosystem that protects the link between this warehouse and the central computer; I've assumed that it's strong and reliable. One good choice would be to use an asymmetric algorithm, where the random-key-generator box in the warehouse uses the central computer's public key to encrypt its reports on which keys have been assigned to which units.

Cryptography

There has always been a need to transfer messages from one location to another. Earlier people used to send messages through messengers who used to travel long distances to deliver them. Slowly a need to make this transmission secure came up. In situations like war, the message being intercepted by the enemy could have changed the whole situation. To tackle such scenarios people started to invent techniques to conceal the original message, so that even if the message is intercepted it cannot be understood by anyone except the desired receiver. One of the simplest examples is Caesar cipher, in which each letter is replaced by another with a fixed alphabet position difference, so if the position difference is 4 (right), then A would become D, B would become E, and so on. In modern era, technology has advanced a lot and so has the techniques to encrypt as well as break it.