IBM Mainframe Forum Index
 
Log In
 
IBM Mainframe Forum Index Mainframe: Search IBM Mainframe Forum: FAQ Register
 

fast data scrambling


IBM Mainframe Forums -> PL/I & Assembler
Post new topic   Reply to topic
View previous topic :: View next topic  
Author Message
jzhardy

Active User


Joined: 31 Oct 2006
Posts: 139
Location: brisbane

PostPosted: Tue Aug 13, 2024 1:08 pm
Reply with quote

hi all,

I have a requirement to write a user exit (in Optim) to scramble data. The options are either COBOL or HLASM.

The target data varies from char 20 though to varchar 4000.

The current solution (using LUA running under Optim) is not viable long term, and not just because of the inefficiently of the interpretive environment.

For a simple example, here are my requirements for a generic "text" column scramble function:

Upper alpha => upper alpha
Lower alpha => lower alpha
Number => number
Other => (not scrambled)


In my solution (below), the pseudo-random element is driven by a hash on record instance id and the contents of the db2 column.

so, with input of (iid = 12345, inText = "Jonathan 1234567 .;#') , I would calculate a hash as: (iid + hash(inText)) mod 256 which becomes a pointer to an array of random bytes.

Looking at what I've coded, it strikes me - and hence my reason for dropping COBOL into this forum - that HLASM could offer a more elegant and efficient solution.

Does anyone have any suggestions or code snippets that could point me in the right direction. Potential for use of SIMD instructions or is that overkill?


here's my first cut solution in COBOL - branchless style. non-portable, obviously.

Code:
       IDENTIFICATION DIVISION.
       PROGRAM-ID. SCRAM.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 WS-STATIC.
         05 WS-HASH-TBL.
           10 FILLER            PIC X(16) VALUE
               X'00000000000000010000000200000003'.
           10 FILLER            PIC X(16) VALUE
               X'00000004000000050000000600000007'.
           10 FILLER            PIC X(16) VALUE
               X'00000008000000090000000A0000000B'.
           10 FILLER            PIC X(16) VALUE
               X'0000000C0000000D0000000E0000000F'.
           10 FILLER            PIC X(16) VALUE
               X'00000010000000110000001200000013'.
           10 FILLER            PIC X(16) VALUE
               X'00000014000000150000001600000017'.
           10 FILLER            PIC X(16) VALUE
               X'00000018000000190000001A0000001B'.
           10 FILLER            PIC X(16) VALUE
               X'0000001C0000001D0000001E0000001F'.
           10 FILLER            PIC X(16) VALUE
               X'00000020000000210000002200000023'.
           10 FILLER            PIC X(16) VALUE
               X'00000024000000250000002600000027'.
           10 FILLER            PIC X(16) VALUE
               X'00000028000000290000002A0000002B'.
           10 FILLER            PIC X(16) VALUE
               X'0000002C0000002D0000002E0000002F'.
           10 FILLER            PIC X(16) VALUE
               X'00000030000000310000003200000033'.
           10 FILLER            PIC X(16) VALUE
               X'00000034000000350000003600000037'.
           10 FILLER            PIC X(16) VALUE
               X'00000038000000390000003A0000003B'.
           10 FILLER            PIC X(16) VALUE
               X'0000003C0000003D0000003E0000003F'.
           10 FILLER            PIC X(16) VALUE
               X'00000040000000410000004200000043'.
           10 FILLER            PIC X(16) VALUE
               X'00000044000000450000004600000047'.
           10 FILLER            PIC X(16) VALUE
               X'00000048000000490000004A0000004B'.
           10 FILLER            PIC X(16) VALUE
               X'0000004C0000004D0000004E0000004F'.
           10 FILLER            PIC X(16) VALUE
               X'00000050000000510000005200000053'.
           10 FILLER            PIC X(16) VALUE
               X'00000054000000550000005600000057'.
           10 FILLER            PIC X(16) VALUE
               X'00000058000000590000005A0000005B'.
           10 FILLER            PIC X(16) VALUE
               X'0000005C0000005D0000005E0000005F'.
           10 FILLER            PIC X(16) VALUE
               X'00000060000000610000006200000063'.
           10 FILLER            PIC X(16) VALUE
               X'00000064000000650000006600000067'.
           10 FILLER            PIC X(16) VALUE
               X'00000068000000690000006A0000006B'.
           10 FILLER            PIC X(16) VALUE
               X'0000006C0000006D0000006E0000006F'.
           10 FILLER            PIC X(16) VALUE
               X'00000070000000710000007200000073'.
           10 FILLER            PIC X(16) VALUE
               X'00000074000000750000007600000077'.
           10 FILLER            PIC X(16) VALUE
               X'00000078000000790000007A0000007B'.
           10 FILLER            PIC X(16) VALUE
               X'0000007C0000007D0000007E0000007F'.
           10 FILLER            PIC X(16) VALUE
               X'00000080000100810001008200010091'.
           10 FILLER            PIC X(16) VALUE
               X'000100910001009200010092000100A2'.
           10 FILLER            PIC X(16) VALUE
               X'000100A2000100A20000008A0000008B'.
           10 FILLER            PIC X(16) VALUE
               X'0000008C0000008D0000008E0000008F'.
           10 FILLER            PIC X(16) VALUE
               X'00000090000100910001009200010081'.
           10 FILLER            PIC X(16) VALUE
               X'000100810001008200010082000100A2'.
           10 FILLER            PIC X(16) VALUE
               X'000100A2000100A20000009A0000009B'.
           10 FILLER            PIC X(16) VALUE
               X'0000009C0000009D0000009E0000009F'.
           10 FILLER            PIC X(16) VALUE
               X'000000A0000000A1000100A2000100A2'.
           10 FILLER            PIC X(16) VALUE
               X'00010081000100810001008200010082'.
           10 FILLER            PIC X(16) VALUE
               X'000100910001009100010092000000AB'.
           10 FILLER            PIC X(16) VALUE
               X'000000AC000000AD000000AE000000AF'.
           10 FILLER            PIC X(16) VALUE
               X'000000B0000000B1000000B2000000B3'.
           10 FILLER            PIC X(16) VALUE
               X'000000B4000000B5000000B6000000B7'.
           10 FILLER            PIC X(16) VALUE
               X'000000B8000000B9000000BA000000BB'.
           10 FILLER            PIC X(16) VALUE
               X'000000BC000000BD000000BE000000BF'.
           10 FILLER            PIC X(16) VALUE
               X'000000C0000000C1000000C2000000C3'.
           10 FILLER            PIC X(16) VALUE
               X'000000C4000000C5000000C6000000C7'.
           10 FILLER            PIC X(16) VALUE
               X'000000C8000000C9000000CA000000CB'.
           10 FILLER            PIC X(16) VALUE
               X'000000CC000000CD000000CE000000CF'.
           10 FILLER            PIC X(16) VALUE
               X'000000D0000000D1000000D2000000D3'.
           10 FILLER            PIC X(16) VALUE
               X'000000D4000000D5000000D6000000D7'.
           10 FILLER            PIC X(16) VALUE
               X'000000D8000000D9000000DA000000DB'.
           10 FILLER            PIC X(16) VALUE
               X'000000DC000000DD000000DE000000DF'.
           10 FILLER            PIC X(16) VALUE
               X'000000E0000000E1000000E2000000E3'.
           10 FILLER            PIC X(16) VALUE
               X'000000E4000000E5000000E6000000E7'.
           10 FILLER            PIC X(16) VALUE
               X'000000E8000000E9000000EA000000EB'.
           10 FILLER            PIC X(16) VALUE
               X'000000EC000000ED000000EE000000EF'.
           10 FILLER            PIC X(16) VALUE
               X'000100F0000100F1000100F2000100F0'.
           10 FILLER            PIC X(16) VALUE
               X'000100F1000100F2000100F0000100F1'.
           10 FILLER            PIC X(16) VALUE
               X'000100F2000100F0000000FA000000FB'.
           10 FILLER            PIC X(16) VALUE
               X'000000FC000000FD000000FE000000FF'.
         05 WS-HASH-TBL-X REDEFINES WS-HASH-TBL OCCURS 256 TIMES
             PIC 9(05) COMP-5.
         05 WS-RANDOM-TBL.
            10 FILLER            PIC X(16) VALUE
               X'009B008500B6002100E700110088008B'.
            10 FILLER            PIC X(16) VALUE
               X'006600EC000600D9006F009400F1004E'.
            10 FILLER            PIC X(16) VALUE
               X'008A003A002300F90015009300F5001F'.
            10 FILLER            PIC X(16) VALUE
               X'005B00480040003800E900EB00940053'.
            10 FILLER            PIC X(16) VALUE
               X'0076004400F700F800AC0099008200EE'.
            10 FILLER            PIC X(16) VALUE
               X'00A700F0005C001D005000A30057001F'.
            10 FILLER            PIC X(16) VALUE
               X'00870022005500A900FC00DA004D008E'.
            10 FILLER            PIC X(16) VALUE
               X'00CB006000A700E9008A005600A500AB'.
            10 FILLER            PIC X(16) VALUE
               X'00DE008100BD00D5001B005B00FA0023'.
            10 FILLER            PIC X(16) VALUE
               X'0045002F002600830093003E00EA00B1'.
            10 FILLER            PIC X(16) VALUE
               X'00B600B50071001B008D0084000F007C'.
            10 FILLER            PIC X(16) VALUE
               X'0073001600270054004B0087007D001D'.
            10 FILLER            PIC X(16) VALUE
               X'00DA001800CE008700D400A7004E0096'.
            10 FILLER            PIC X(16) VALUE
               X'0080004A00090088006B006B00FC00A6'.
            10 FILLER            PIC X(16) VALUE
               X'00CF00FC0028008A00CB008B00630005'.
            10 FILLER            PIC X(16) VALUE
               X'00E2009200F8003E00AD007A0053009C'.
            10 FILLER            PIC X(16) VALUE
               X'00CF0081008A000F00E0000800F800D0'.
            10 FILLER            PIC X(16) VALUE
               X'005600B70020000F000900D3000A0045'.
            10 FILLER            PIC X(16) VALUE
               X'005C00D100E300D9005500F00027004E'.
            10 FILLER            PIC X(16) VALUE
               X'009D004D006400F6009700AF009100C4'.
            10 FILLER            PIC X(16) VALUE
               X'00D800D700AA001100C800C4007A00CD'.
            10 FILLER            PIC X(16) VALUE
               X'008900D7003900740073005600030008'.
            10 FILLER            PIC X(16) VALUE
               X'007C007B00DE00A00083009200D80082'.
            10 FILLER            PIC X(16) VALUE
               X'00AC006F00E600A4006E0059002F0004'.
            10 FILLER            PIC X(16) VALUE
               X'004C009A00CA00DD00E30003004C0003'.
            10 FILLER            PIC X(16) VALUE
               X'00D400CA009D00EC00A400D2006700F8'.
            10 FILLER            PIC X(16) VALUE
               X'003A00B100B0007700F000ED00930060'.
            10 FILLER            PIC X(16) VALUE
               X'00AB002400DE006D002C00A900B30067'.
            10 FILLER            PIC X(16) VALUE
               X'003500EA00AA005B001800E700E60055'.
            10 FILLER            PIC X(16) VALUE
               X'00530092001200F3001C006F00FD00DB'.
            10 FILLER            PIC X(16) VALUE
               X'0036000500C0004C00A600AC001900A3'.
            10 FILLER            PIC X(16) VALUE
               X'0028003A00770072008A007D00510099'.
          05 WS-RANDOM-TBL-X REDEFINES WS-RANDOM-TBL OCCURS 256 TIMES
             PIC 9(03) COMP-5.
       01 WS-WORKING COMP-5.
          05 WS-IX            PIC 9(03).
          05 WS-IN-FNAME-LEN  PIC 9(03).
          05 WS-IN-FNAME-HASH PIC 9(03).
          05 WS-IID-COL-HASH  PIC 9(03).
          05 WS-BYTE-TO-MAP   PIC 9(03).
          05 WS-BYTE-MAPPED   PIC 9(03).
          05 WS-RAND-0-THRU-7 PIC 9(01).
          05 WS-REMAP-FW      PIC 9(05).
          05 WS-REMAP-HL      REDEFINES WS-REMAP-FW.
             10 WS-REMAP-H    PIC 9(03).
             10 WS-REMAP-L    PIC 9(03).
       01 WS-IMPORT.
          05 WS-IID      PIC 9(16).
          05 WS-IN-FNAME PIC X(20).
       01 WS-EXPORT.
          05 WS-OUT-FNAME PIC X(20).

       PROCEDURE DIVISION.
           INITIALIZE WS-EXPORT, WS-WORKING.
           MOVE 'Jonathan01#####77777' TO WS-IN-FNAME.
           MOVE 20 TO WS-IN-FNAME-LEN.
           MOVE 12345 TO WS-IID.

      * >  Calculate a hash based on Record Identifier X Input String
           PERFORM VARYING WS-IX FROM 1 BY 1 UNTIL WS-IX >
                   WS-IN-FNAME-LEN
               COMPUTE WS-IN-FNAME-HASH =
                   FUNCTION MOD(WS-IN-FNAME-HASH + FUNCTION
                       ORD(WS-IN-FNAME(WS-IX:1)), 256)
           END-PERFORM
           COMPUTE WS-IID-COL-HASH = 1 + FUNCTION
               MOD(WS-IID + WS-IN-FNAME-HASH, 256)

      * >  Randomise A-Z,a-z and 0-9 as per WS-HASH-TBL x WS-RANDOM-TBL
           MOVE 0 TO WS-IX
           PERFORM UNTIL WS-IX = WS-IN-FNAME-LEN
              COMPUTE WS-IX = WS-IX + 1
              COMPUTE WS-BYTE-TO-MAP = FUNCTION
                  ORD(WS-IN-FNAME(WS-IX:1))
              MOVE WS-HASH-TBL-X(WS-BYTE-TO-MAP) TO WS-REMAP-FW
              COMPUTE WS-RAND-0-THRU-7 = FUNCTION
                  MOD(WS-RANDOM-TBL-X(WS-IID-COL-HASH), 8)
              COMPUTE WS-BYTE-MAPPED = WS-REMAP-L + WS-REMAP-H *
                  WS-RAND-0-THRU-7
              MOVE FUNCTION CHAR(WS-BYTE-MAPPED + 1) TO
                 WS-OUT-FNAME(WS-IX:1)
              COMPUTE WS-IID-COL-HASH = 1 + FUNCTION
                  MOD(WS-IID-COL-HASH + 1, 256)
           END-PERFORM
           STOP RUN.
Back to top
View user's profile Send private message
sergeyken

Senior Member


Joined: 29 Apr 2008
Posts: 2140
Location: USA

PostPosted: Tue Aug 13, 2024 7:48 pm
Reply with quote

When using HLASM, there are useful instructions to make characters replacement in the whole string as defined via a translate table:

TR STRING,TRANTAB
(Translate) - replaces characters in a string up to 256 bytes maximum. In case of a longer string the TR instruction needs to be used in a loop.

TRE RSTRING,RTRANTAB
(Translate Extended) - replaces characters in a string up to 2GB maximum.

Before using any of those instruction, you may need to modify a 256-bytes translation table of characters based on your own hash requirements.

This is a general approach which can be used. Coding a real example with hashing etc. may take some time. icon_rolleyes.gif
Back to top
View user's profile Send private message
jzhardy

Active User


Joined: 31 Oct 2006
Posts: 139
Location: brisbane

PostPosted: Wed Aug 14, 2024 5:06 am
Reply with quote

I did think of using INSPECT..REPLACING to scramble the data, but then I'd be forced to reduce the target range to make it secure from a statistical attack, or possibly repeat that command with different parameters ...

[Much of the data is long varchar. If a repeated token like 'xyz' appears, one might guess a source value of 'the' and be well on the way to decoding the whole string]

So, yes, I could map [A-Z] => [A-M] and that would make it stronger. But then I have the problem that two distinct tokens (words) are more likely to map into a common value. I want a kind of isomorphism in my mapping function, such that (1\) the 'distinct' property is preserved, and (2\) token (word) lengths are preserved.

my solution above does not actually enforce (1\), but does a good enough job.

I should have abstracted the problem into a more general requirement. What I'm really after is a way to parallelize a set of linear functions, for example, with:

L: (x'91', x'81' ,x'BC')
H: (1, 1 , 0)
X: (4 , 3 ,7)

I want a result vector R, such that:
R(i) = L(i) + [H(i) * X(i)]

in the example above i would just get : (x'95',x'84',x'BC')
Back to top
View user's profile Send private message
sergeyken

Senior Member


Joined: 29 Apr 2008
Posts: 2140
Location: USA

PostPosted: Wed Aug 14, 2024 6:45 pm
Reply with quote

I hope your scrambling can (or must) be irreversible?
Back to top
View user's profile Send private message
sergeyken

Senior Member


Joined: 29 Apr 2008
Posts: 2140
Location: USA

PostPosted: Wed Aug 14, 2024 6:50 pm
Reply with quote

jzhardy wrote:
I should have abstracted the problem into a more general requirement. What I'm really after is a way to parallelize a set of linear functions, for example, with:

L: (x'91', x'81' ,x'BC')
H: (1, 1 , 0)
X: (4 , 3 ,7)

I want a result vector R, such that:
R(i) = L(i) + [H(i) * X(i)]

in the example above i would just get : (x'95',x'84',x'BC')

How to you expect to maintain your initial requirement:

Uppercase -> Uppercase
Lowercase -> Lowercase
Digits -> Digits?
Back to top
View user's profile Send private message
Pedro

Global Moderator


Joined: 01 Sep 2006
Posts: 2593
Location: Silicon Valley

PostPosted: Thu Aug 15, 2024 1:04 am
Reply with quote

Code:
R(i) = L(i) + [H(i) * X(i)]


If that is what you want to do, it seems like you just need to set up your three arrays, then load individual bytes into registers and finally to perform the required math. And do the same for every byte of your string.

Try Load Logical Character instruction to load a byte into a register:

Code:
LLGC R1,D1(X2,B2)


See the Principles of Operation manual, SA22-7832
Back to top
View user's profile Send private message
jzhardy

Active User


Joined: 31 Oct 2006
Posts: 139
Location: brisbane

PostPosted: Thu Aug 15, 2024 4:43 am
Reply with quote

I haven't been able to find the latest version of the POP : SA22-7832-13.

Looking though the version I have (dated Dec 2000) I couldn't find any vector operations that would enable the kind of internal parallelism that I'm looking for.

For the record, I get good performance from my existing solution, so this is perhaps something of an academic exercise.

If someone can drop a working link to SA22-7832-13 I would be very grateful !
Back to top
View user's profile Send private message
sergeyken

Senior Member


Joined: 29 Apr 2008
Posts: 2140
Location: USA

PostPosted: Thu Aug 15, 2024 4:50 am
Reply with quote

Pedro wrote:
Try Load Logical Character instruction to load a byte into a register:

Code:
LLGC R1,D1(X2,B2)


See the Principles of Operation manual, SA22-7832

Why not to use the simple instruction?
Code:
  IC  R1,D2(X2,B2)

Anyway, it doesn't help to satisfy the original requirements of this topic... icon_question.gif
Back to top
View user's profile Send private message
jzhardy

Active User


Joined: 31 Oct 2006
Posts: 139
Location: brisbane

PostPosted: Thu Aug 15, 2024 12:27 pm
Reply with quote

I managed to find a copy of SA22-7832-13 on www.vm.ibm.com/library/other.html

VMAL(B) comes closest to what I'm looking for. Some overheads in packing the vectors, but i think I can make it work.

I'll post again when I have a good working solution.
Back to top
View user's profile Send private message
sergeyken

Senior Member


Joined: 29 Apr 2008
Posts: 2140
Location: USA

PostPosted: Fri Aug 16, 2024 1:53 am
Reply with quote

Usually I am an opponent to any rocket-science-like methods, unless it is really needed (very rarely that happens).

Though I did not receive an answer to any of my questions, I would do it in a much more simple way.


1. Prepare several scrambled lists of possible characters translation rules.

Do it for the first group (e.g. uppercase letters)

Code:
ABCDEFGHIJKLMNOPQRSTUVWXYZ   
            - split randomly into 3 parts
         ABCDEF   GHIJKLM   NOPQRSTUVWXYZ   
            - reorder parts in reverse order
         NOPQRSTUVWXYZ  GHIJKLM   ABCDEF   
            - concatenate 3 parts again
NOPQRSTUVWXYZGHIJKLMABCDEF    - repeat as many times as needed
WXYZABCDEFJKLMNOPQRSTUVGHI
UVGHIKLMNOPQRSTWXYZABCDEFJ
ZABCDEFJNOPQRSTWXYUVGHIKLM
IKLMEFJNOPQRSTWXYUVGHZABCD
. . . . . . . etc . . . . . . .

Do the same for another group (e.g. lowercase letters)

Code:
abcdefghijklmnopqrstuvwxyz
pqrstuvwxyzdefghijklmnoabc
mnoabcuvwxyzdefghijklpqrst
qrstwxyzdefghijklpmnoabcuv
cuvxyzdefghijklpmnoabqrstw
rstwefghijklpmnoabqcuvxyzd
. . . . . . . etc . . . . . . .

Do the same for another group (e.g. numeric characters)

Code:
0123456789
6789234501
1506789234
4789231506
5069231478
8314750692
. . . . . . . etc . . . . . . .


As the result there are several common translation tables (5 to many)

Code:
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 - original set of affected characters
NOPQRSTUVWXYZGHIJKLMABCDEFpqrstuvwxyzdefghijklmnoabc6789234501 - translation #1
WXYZABCDEFJKLMNOPQRSTUVGHImnoabcuvwxyzdefghijklpqrst1506789234 - translation #2
UVGHIKLMNOPQRSTWXYZABCDEFJqrstwxyzdefghijklpmnoabcuv4789231506 - translation #3
ZABCDEFJNOPQRSTWXYUVGHIKLMcuvxyzdefghijklpmnoabqrstw5069231478 - translation #4
IKLMEFJNOPQRSTWXYUVGHZABCDrstwefghijklpmnoabqcuvxyzd8314750692 - translation #5
. . . . . . . etc . . . . . . .


2. Create translation tables depending on the used tool.

Based on the used translation mechanism, those tables can be pairs of matching character strings (such as used by REXX TRANSLATE() function), or several 256-bytes translation tables (such as used by Assembler TR/TRE instructions), or whatever else.

3. Select limited portions of input text to be scrambled (with the length from 1 character to, let’s say, 100 characters; optionally varying random size of each portion can be used).

The shorter is each part of the text, the better it is protected against the statistical breaking methods. Ideally it can be 1 character each, though it takes more resources to scramble large text. Randomly varying size of text part should also work fine, and faster than 1-character parts.

4. Translate each portion of text using a particular translation table. For every following portion use the next one of created translation tables, in a loop.

One part of text is scrambled using one translation table. For each following part of text just switch to the next translation table of the once prepared group of tables.
Back to top
View user's profile Send private message
jzhardy

Active User


Joined: 31 Oct 2006
Posts: 139
Location: brisbane

PostPosted: Mon Aug 19, 2024 10:57 am
Reply with quote

here's a slightly better solution to what I first posted. 'Better' in the sense that it illustrates where vector operations could be exploited, not in the sense of being particularly good COBOL.

When I get some time later this week I'll get some performance stats, and then compare it with another version that replaces OBF-PARA with a call to an assembler module.

Code:
        IDENTIFICATION DIVISION.
        PROGRAM-ID. SCRAM.
        DATA DIVISION.
        WORKING-STORAGE SECTION.
        01 WS-STATIC.
              05 WS-ALPHA-OFFSET-TBL.
               10 FILLER PIC X(24) VALUE
                  x'001222070424001408040022170005150315222101022718'.
... (skipped 20 lines)
               10 FILLER PIC X(08) VALUE
                  X'2806110612212618'.
            05 WS-ALPHA-OFFSET-X REDEFINES WS-ALPHA-OFFSET-TBL
                  OCCURS 272 TIMES PIC X.
            05 WS-NUM-OFFSET-TBL.
               10 FILLER PIC X(24) VALUE
                  X'040803010002060505030408040401000408070206080601'.
... (skipped 20 lines)
               10 FILLER PIC X(08) VALUE
                  X'0100030806010706'.
             05 WS-NUM-OFFSET-X REDEFINES WS-NUM-OFFSET-TBL
                  OCCURS 272 TIMES PIC X.
       01 WS-WORKING.
            05 WS-IN-IID        PIC 9(18) BINARY.
            05 WS-1-THRU-256    PIC 999 BINARY.
            05 WS-IN-TEXT       PIC X(100).
            05 WS-IN-TEXT-LEN   PIC S9(4).
            05 WS-IN-TEXT-IX    PIC 9(4) BINARY.
            05 WS-IN-TEXT-HASH  PIC 9999 BINARY.
            05 WS-IX            PIC 99 BINARY.
       01 WS-EXPORT.
            05 WS-OUT-TEXT       PIC X(100).
            05 WS-OUT-TEXT-LEN   PIC S9(4).

       PROCEDURE DIVISION.
           INITIALIZE WS-EXPORT, WS-WORKING.

           MOVE 1234567 TO WS-IN-IID.
           MOVE 'Jonathan123 &*.1abcdeABCDE 1234567$%^' TO WS-IN-TEXT.
           MOVE 37 TO WS-IN-TEXT-LEN, WS-OUT-TEXT-LEN.
           DISPLAY WS-IN-TEXT.
           INSPECT WS-IN-TEXT CONVERTING
                   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
      -            "0123456789"
           TO
                     "AAAAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaaaaaaaaaaaaaaaaa
        -            "0000000000"
             PERFORM VARYING WS-IN-TEXT-IX FROM 1 BY 1 UNTIL
                  WS-IN-TEXT-IX > WS-IN-TEXT-LEN
                COMPUTE WS-IN-TEXT-HASH =
                 FUNCTION MOD(WS-IN-TEXT-HASH +
                 FUNCTION ORD(WS-IN-TEXT(WS-IN-TEXT-IX:1)), 256)
             END-PERFORM
             COMPUTE WS-1-THRU-256 =
                FUNCTION MOD (WS-IN-IID+WS-IN-TEXT-HASH, 256) + 1
   
           PERFORM OBF-PARA VARYING WS-IN-TEXT-IX FROM 1 BY 16
              UNTIL WS-IN-TEXT-IX > WS-IN-TEXT-LEN

           DISPLAY WS-OUT-TEXT.
           STOP RUN.

       OBF-PARA.
           PERFORM VARYING WS-IX FROM 0 BY 1 UNTIL WS-IX > 15

           EVALUATE WS-IN-TEXT(WS-IN-TEXT-IX + WS-IX:1)
             WHEN 'A'
             WHEN 'a'
                MOVE FUNCTION CHAR(
                  FUNCTION ORD(WS-IN-TEXT(WS-IN-TEXT-IX+WS-IX:1)) +
                  FUNCTION ORD(WS-ALPHA-OFFSET-X(WS-1-THRU-256)) - 1
                             ) TO WS-OUT-TEXT(WS-IN-TEXT-IX+WS-IX:1)
             WHEN '0'
                MOVE FUNCTION CHAR(
                  FUNCTION ORD(WS-IN-TEXT(WS-IN-TEXT-IX+WS-IX:1)) +
                  FUNCTION ORD(WS-NUM-OFFSET-X(WS-1-THRU-256)) - 1
                              ) TO WS-OUT-TEXT(WS-IN-TEXT-IX+WS-IX:1)
             WHEN OTHER
                  MOVE WS-IN-TEXT(WS-IN-TEXT-IX+WS-IX:1) TO
                       WS-OUT-TEXT(WS-IN-TEXT-IX+WS-IX:1)
           END-EVALUATE

           COMPUTE WS-1-THRU-256 =
              FUNCTION MOD(WS-1-THRU-256 + 1, 256) + 1
           END-PERFORM.


the assembler module (replacing OBF-PARA) could do something like (very crudely):

load V0 with 16 bytes (from source string)
load V1 with 16 bytes - random nums from WS-ALPHA-OFFSET-X ( ptr)
load V2 with 16 bytes - random nums from WS-NUM-OFFSET-X (ptr)
set V3 (bytes), so that value 1 => char is A-Z;a-z
set V4 (bytes), so that value 1 => char is 0-9

derive result vector and store.
Back to top
View user's profile Send private message
View previous topic :: :: View next topic  
Post new topic   Reply to topic View Bookmarks
All times are GMT + 6 Hours
Forum Index -> PL/I & Assembler

 


Similar Topics
Topic Forum Replies
No new posts db2 vs static data COBOL Programming 1
No new posts External data queue (changes?) CLIST & REXX 0
No new posts Pull data using date difference betwe... DB2 6
No new posts How to save SYSLOG as text data via P... All Other Mainframe Topics 4
No new posts Store the data for fixed length COBOL Programming 1
Search our Forums:

Back to Top