Learn what the Calculate Hash API can do for you.

In the past month, I've been asked two related questions. The first was "Can my AS/400 [sic] work with hashes?" and the second, a bit more specific, "Can the i generate a SHA-256 hash to work with a Linux system?" The answer to both questions, as you might expect, is yes, there's an API for that (as long as the system is at V5R3 or higher that is, in the case of the AS/400 question).

Hashing, if you are not familiar with the term, is a mechanism by which a fixed-length value can be generated from a string of data in such as way that it is extremely unlikely that some other data string will generate the same hash value. That is, if one program writes a string such as "The i is the best system in the world," which hashes to the value X, and another program subsequently reads a different string (due to "someone" altering the original value) and generates a hash value based on the altered string, then it is highly unlikely that the second program will also generate X. If the second program generates X, then no one has changed the data. If the second program generates Y, then the data has been altered. The writing of the original data string might be to another system, a DB2 table on the same system, an IFS stream file, or whatever other mechanism you might want to use within your application. The original hash value X might be written with the original string in an encrypted form using a key known by the receiving program, written to read-only storage for later access by the receiving program, or protected in some other fashion that allows the receiving program to determine the original hash value of X.

The Calculate Hash API, documented here, is provided as both a program (QC3CALHA) and a procedure (Qc3CalculateHash). The following program demonstrates how to use the Qc3CalculateHash procedure to hash the string 'Some data to be hashed'.

h dftactgrp(*no)                                                          

d HshDta         pr                 extproc('Qc3CalculateHash')          

d InpDta                     4096a   const options(*varsize)              

d LenInpDta                   10i 0 const                                

d FmtInpDta                     8a   const                                

d AlgDsc                     4096a   const options(*varsize)              

d FmtAlgDsc                     8a   const                                

d CryptoPrv                     1a   const                                

d CryptoDev                    10a   const                                

d HshVal                       1a   options(*varsize)                    

d ErrCde                             likeds(qusec)                        

d Data           s             25a   inz('Some data to be hashed')        

d HashValue       s             32a                                        

/copy qsysinc/qrpglesrc,qc3cci                                            

/copy qsysinc/qrpglesrc,qusec                                            

/free                                                  

QUSBPrv = 0;                                          

QC3HA = 3;                                            

HshDta(Data :%len(%trimr(Data)) :'DATA0100'          

         :QC3D0500 :'ALGD0500' :'0' :' '                

         :HashValue :QUSEC);                            

*inlr = *on;                                          

return;                                              

/end-free                                              

As you can see, there's not much to the program!

The program starts by prototyping the Qc3CalculateHash API using the name HshDta. The nine parameters passed to the API are used in the following manner:

1. Input data (InpDta)—Depending on the Input data format (the third parameter), either a variable-length string containing the data to be hashed or an array identifying one or more variable-length strings containing the data to be hashed
2. Length of input data (LenInpDta)—Depending on the Input data format (the third parameter), either the length of the Input data to be hashed or the number of array entries to process within the Input data parameter
3. Input data format name (FmtInpDta)—The format of the Input data (the first parameter). Format DATA0100 indicates that a single variable-length string is to be hashed, Format DATA0200 that an array of variable-length strings are to be hashed
4. Algorithm description (AlgDsc)—The algorithm to be used when hashing the data
5. Algorithm description format name (FmtAlgDsc)—The format of the Algorithm description (the fourth parameter). Format ALGD0100 indicates that the Calculate Hash API may be called multiple times in order to process all of the data to be hashed. Using this format, the algorithm to be used is defined using another API (which will be reviewed in a future article). Format ALGD0500 indicates that the Calculate Hash API will be called once (with all of the data to be hashed) and that the algorithm to be used can be found directly in the fourth parameter. Other formats are defined (ALGD0200, ALGD0300, etc.) but are used for functions other than hashing.
6. Cryptographic service provider (CryptoPrv)—Depending on the system configuration, you may have both software and hardware cryptographic capabilities. A value of '0' indicates that the system should decide where to perform the hashing function, a value of '1' that software should be used to perform the hashing function, and a value of '2' that hardware should be used to perform the hashing function.
7. Cryptographic device name (CryptoDev)—When the sixth parameter indicates that hardware should be used to perform the hashing function, this parameter identifies the name of the cryptographic device.
8. Hash (HshVal)—The parameter to receive the generated hash value. The size of this parameter is determined by the algorithm being used.
9. Error code (ErrCde)—The standard API error code parameter

Having prototyped the Calculate Hash API, the program then sets the Bytes provided field (QUSBPrv) of the error code structure to 0 (indicating that errors are to be returned as escape messages), sets the Hash algorithm to be used (QC3HA) to 3 (indicating the algorithm to be used is SHA-256), and calls the API. The field QC3HA is defined as an element of the structure QC3D0500, which is provided in member QC3CCI of source file QSYSINC/QRPGLESRC.

The hash algorithm to be used (QC3HA) supports the following values:

1. MD-5 returns a hash value of 16 bytes in length.
2. SHA-1 returns a hash value of 20 bytes in length.
3. SHA-256 returns a hash value of 32 bytes in length.
4. SHA-384 returns a hash value of 48 bytes in length.
5. SHA-512 returns a hash value of 64 bytes in length.

Using tools such as Google, you can find more information than you probably ever wanted on each of these algorithms. The key points I would like to make are:

1. The algorithm selected determines the size you need to allocate for the Hash value parameter. As we're using value 3, SHA-256, in the sample program we've allocated 32 bytes for the HashValue field passed as the 8^th parameter (HshVal) of the API.
2. Not all of these algorithms should be used for new development. The first two algorithms (MD-5 and SHA-1) are considered weak and are supported by the API primarily for compatibility with existing application use of hashing. New development, where possible, should use the algorithms SHA-256, SHA-384, or SHA-512.

When calling the Calculate Hash API, the data to be hashed is variable Data, the length of the data to be hashed is the blank trimmed length of variable Data, the data format used is DATA0100, the algorithm is SHA-256, all of the data to be hashed is passed on this API call, the system is to determine where to perform the hashing, and the generated hash value is to be returned to variable HashValue.

Assuming that the sample program is stored in member DOHASH of source file QRPGLESRC, you can create the program using the command CRTBNDRPG PGM(DOHASH).

Calling DOHASH will generate a 32-byte HashValue (shown in hex) of:

06E931E8 C399BD60 B3FC4263 C21BCDF3

F8BD668A 6AF9278E 2791D2B0 95DD8F92

In order to demonstrate how any alteration of the data to be hashed can impact the generated hash value, let's change the call to the API from using a second parameter of %len(%trimr(Data)) to using a parameter value of %size(Data). The difference here is that while Data is defined with a length of 25 bytes, the string 'Some data to be hashed' is only 22 bytes in length. Using the %size built-in will have the effect of having the API process three trailing blanks.

Recompiling and calling DOHASH after this change now generates a 32-byte HashValue of:

7FCBD451 76B2E190 AFC956AE F507CB35

A9C7F58B 36A68E25 58E9F3F9 736FB213

This new HashValue, as I'm sure you've noticed, is fundamentally different. Altering the string to be hashed by simply adding three blanks is more than sufficient for a new hash value to be generated. So you need to make sure that whatever program is generating a hash value in order to verify that a string has not been altered is using the same assumptions (length in this case) as the program originally generating the hash value to be compared with.

Given that just adding three blanks changed the generated hash value, it should be no surprise that adding a period to the end of the string ('Some data to be hashed. ' where there are two blanks following the period) will also generate a wildly different HashValue:

E32F1577 B88BD513 78551D15 13E5C4D3

3765A423 FDF4975D DD56CE70 63069806

Before closing, I would like to point out one "gotcha" that may save you minutes, days, or even weeks of head scratching. Over the years, I've seen several companies take a string such as 'Some data to be hashed', generate a hash value, write the string to a database file, FTP the file to another system, and then find that the string, when hashed on the other system, generates a different hash. As their use of the Calculate Hash API is new, they assume that they are using the API incorrectly when in fact their use is right on. What is typically the case is that the FTP operation converted the EBCDIC string 'Some data to be hashed' to the ASCII string 'Some data to be hashed' and, just as adding a blank to the string to be hashed changed the generated hash value, converting the data from EBCDIC to ASCII also changed the generated hash value. Along the same lines, writing the string 'Some data to be hashed' to an IFS stream file can, depending on how your job and stream file are defined, cause the system to perform an EBCDIC-to-ASCII conversion under the covers. So make sure the data you are generating the hash from is indeed the data that will be subsequently used when generating the hash value to verify that the data has not been altered (length of data, encoding of data, etc.).

As usual, if you have any API questions, send them to me at This email address is being protected from spambots. You need JavaScript enabled to view it..