I think you gotta hit her with a Neuro Dart - Vector - 6/13/06

Function Decrypt(k,m)

 r = ""
 while (m != ""
 if (m.length < 64)
 c = m
 m = ""
 else
 c = m.substring (0,64)
 m = m.substring (64,m.length)
 if (c % 64 != 0)
 while c.length < 64
 c += '0'
 c = NOT c
 b1 = c.substring(0,32)
 b2 = c.substring(32,64)
 k1 = k.substring(0,32)
 k2 = k.substring(32,64)
 j = 0
 while (j < 32)
 if (j % 2 == 0 )
 b1.charAt(j) = b1.charAt(j) XOR k1.charAt(j)
 b2.charAt(j) = b2.charAt(j) XOR k2.charAt(j)
 j++
 r += right circular shift (b2 + b1)
 return r

Message Edited by Rarebit on 06.16.2006 03:49 PM

Is it me, or does something in that code not make sense (minus the which appears by mistake)? 
Specifically:
r += right circular shift ( b2 + b1)

There are 3 ways to look at this...

1. you do a 1 bit RCS on b2+b1


2. you do a b2+b1 RCS on b2+b1


3. Or it was ment to say r += RSC(b2, b1)  <~~thats my guess

Other ideas?

Plus, is the code significant in any way?

OOC:

Whoo Vector! You guys are bringing it to them!

"The beatings will continue until Moral improves."

-AlicethePattern, Head Archivist, Mega City Department of Energy (Regression - Recursion)

---

Digita1Spirit wrote:
"PBlade: Aha! Have at ye, knave!"

---

---

The_Effectuator wrote:
You know, maybe I could be ZionEveryone's new mission controller.

---

I second this.

"I need to stop watching TV in my head." ~Effectuator.

((Brilliant coverage by The X! Bravo! Even if at some points they were a few jumps behind.))

---

dataslayer wrote:

Is it me, or does something in that code not make sense (minus the which appears by mistake)? 
Specifically:
r += right circular shift ( b2 + b1)

There are 3 ways to look at this...

1. you do a 1 bit RCS on b2+b1


2. you do a b2+b1 RCS on b2+b1


3. Or it was ment to say r += RSC(b2, b1)  <~~thats my guess

Other ideas?

Plus, is the code significant in any way?

---

It seems like right circular shift would be a method(function) with a syntax along the lines of right circular shift(int i); I have no idea what it's meant to do, though. I suppose we're supposed to assume it's a circular shift to the right of letters or something, here's a breakdown of the code:

Function Decrypt(k,m) //Method declared as Decrypt, expects two parameters, k and m

    r = "" //Instance variable r declared as a null string
    while (m != "") //Do this part while variable m is not an empty string
        if (m.length < 64) //If the number of characters in string m is less than 64...
            c = m //set variable c equal to variable m
            m = "" //set variable m equal to an empty string (so the while condition may be fulfilled later)
        else //Otherwise, if m is not an empty string
            c = m.substring (0,64) //set variable c equal to a string of characters from the first character in m to the 64th character in m
            m = m.substring (64,m.length) //set variable m to a string of characters from the 65th character in m to the last character in m
        if (c % 64 != 0) //if the remainder of variable c divided by 64 is not equal to zero
            while c.length < 64 //while the length of c is less than 64
                c += '0' //append a 0 to string c
        c = NOT c //set variable c equal to not c
        b1 = c.substring(0,32) //set instance variable b1 equal to the first character in c to the 32nd character in c
        b2 = c.substring(32,64) //set instance variable b2 equal to the 33rd character in c to the 64th character in c
        k1 = k.substring(0,32) //set instance variable k1 equal to the first character in k to the 32nd character in k
        k2 = k.substring(32,64) //set instance variable k2 equal to the 33rd character in k to the 64th character in k
        j = 0 //set variable j equal to 0
        while (j < 32) //while variable j is less than 32
            if (j % 2 == 0 ) //if the remainder of j divided by 2 is equal to 0
                b1.charAt(j) = b1.charAt(j) XOR k1.charAt(j) //I'll be damned if I remember what an exclusive or does.
                b2.charAt(j) = b2.charAt(j) XOR k2.charAt(j)
            j++ //increment j by 1
        r += right circular shift (b2 + b1) //add the value of a right circular shift of b2 + b1 to r
    return r //ultimately return the value r

There are some somewhat more understandable explanations of programming language. I'll plug all of this into my IDE and see what I can make of it.

Here is the pseudo-code of how that function performs:

- Take string "m" as main input text data (bit code)
- [START]
- copy first 64 chars to "c" and remove them from the front of "m" (8 lots of 8 bits = 8 ASCII characters)
- if "c" is less than 64 chars in length then pad it with 0s at the end (to make it decodeable binary)
- invert "c"... make all 1s 0s and vice versa
- "b1" = first 32 chars from "c"
- "b2" = last 32 chars from "c"
- "k1" = first 32 chars from "k"
- "k2" = last 32 chars from "k"
- for count = 0 to 32 do
-- if count is an even number do
---- XOR character "count" from b1 and k1
---- XOR character "count" from b2 and k2
- "r" = "r" + last character from "b2" + "b1" + first 31 characters of "b2"
- if "m" is empty then return "r" as the decoded text, otherwise go back to [START]

I will post a program that does this shortly

ok... the program is finished and here is what the letters in the pseudo code stand for:

m = message

k = key

r = result

c = characters

b1 = characters bit/part1

b2 = characters bit/part2

k1 = key part 1

k2 = key part 2

the link to the program is http://www.aliciaandnick.com/MxOdecode.zip

once the correct key is found and the messages are decoded then it should be a regular binary decode to get the final message.

OK... there was a minor bug... fixed now. if you downloaded the program please re-download it.

REMEMBER! don't trust programs from places you don't know... that means virus check my program.

one last note:

The copy to clipboard button for the R box now works.
The key (K box) is a 64 digit binary number (possibly the first or last line of each code block)

Message Edited by jl10899 on 06.15.2006 10:40 PM

Message Edited by jl10899 on 06.15.2006 10:41 PM

Sorry dataslayer ... I bungled my code slightly... that's what happens when I run out of coffee.

Message Edited by phi on 06.17.2006 12:33 PM

OK... Here's my code in Object Pascal (Delphi)

var
  M, K, R, c, ctmp, b1, b2, k1, k2: string;
  pos, counter : integer;
begin
  M := editM.Text;
  K := editK.Text;
  R := '';
  while M <> '' do
  begin
    c := '';
    ctmp := '';
    if Length(M) < 64 then
    begin
      c := M;
      M := '';
    end else
    c := Leftstr(M, 64);
    M := midstr(M, 64, Length(M));
    if length(c) MOD 64 <> 0 then
      while length(c) < 64 do c := c + '0';
//  c = NOT c
    for pos := 0 to length(c)-1 do
      if c[pos] = '0' then ctmp := ctmp + '1'
      else if c[pos] = '1' then ctmp := ctmp + '0';
    b1 := Leftstr(ctmp, 32);
    b2 := Rightstr(ctmp, 32);
    k1 := Leftstr(K, 32);
    k2 := Rightstr(K, 32);
    c := '';
    ctmp := '';
    for counter := 0 to 31 do
      if (counter mod 2 = 0) then
      begin
      // XOR
        if (b1[counter] = '1') or (k1[counter] = '1') and (b1[counter] <> k1[counter])
          then c := c + '1' else c := c + '0';
        if (b2[counter] = '1') or (k2[counter] = '1') and (b2[counter] <> k2[counter])
          then ctmp := ctmp + '1' else ctmp := ctmp + '0';
      end
      else begin
      // Add odd numbered positions too
        c := c + b1[counter];
        ctmp := ctmp + b2[counter];
      end;
      // r = RCS(b2+b1)
    R := R + RightStr(c, 1) + ctmp + LeftStr(c, 31);
  end; // End While m <> ''
  editR.Text := R;

The key I was given by a valued contact was f0rEc4ST

In binary that is 64 bits (ASCII not Unicode):
0110011000110000011100100100010101100011001101000101001101010100

The messages I tried this decryption with are:

===========================1=============================
0010000100000101001101010011011101011111000000110001011100110011
0010111100010101000011011011000100011111100001111001111100111111
0001101100101101001011010010001100111001000101011001111100111111
1011111100000101001111010010100100010011100111110011011100001001
0010110100000011001100010001100100010111100111110011011100000111
0010110100110111000101110010011110011101000111011001111100001111
0001011110011111001100110010000100010111100111110000111100001001
1010011110011111000110010010000100111001100111110011010100110001
0001101100010101101111110001100110011101001100010001010110011001
0010111100001101001000110011000100110011000011010011011100010001
0001101110011111000101110010000110011101000000010011001100011101
0011110110011111001100110010110110011101000101110001110100111111
0011001100000001000110111011111100000101000101010011100110010111
0011110100010001001101011011111100000111000101010011100100110001
0000110100111001101000111011111100111001000101010000011100010101
0001100110011111000100010010110101101111000000010011010100110011
0011010110011111001011110011010100000101000001111001111100010011
0010111100110111000101110001111100111001000101011010101110010111
1001010110101101101000110001111110101001100000011000000100000101
0011101100110101001110010010100100001101000000010011011100001001
0010000100000101101000010011110100010111001101111000001100010001
0001100110000001001100011001101100000101000110110011010100001101
1000110100001011100110010110100110101111101101011000000101010101
1001010110000001100110111001110100101101011000010000101110111001
1001000100010101101000110010101100010001101011011010110110110001
0101000100010101101100010001101100111101000100011000001110010111
0001010100110111000101110010110100010111100111110011100100000111
0010000100110001001000111011111100000001000100011001111100011111
1011111100011001001011110011110100110101000011110000110100110001
1010001110011111101001011010010100000001000000110001010100001111
0011010111011111111111111111111101011111000000110000000100001101
===========================2=============================
0011011100010101100001011011111101011011000111010001101100011101
0001011110011111000110010011110100110101000011110010001100011001
0001010100111001100111010011110100111011001101110011111100011011
0001011100110111001101010010110100111001000101011011110100110001
0000111100111001000101111011111100000001000100011011110100010001
0011011100111011100111010011010100110101000000011011110100100001
0011110100110111000101110011011100000001000110010001100100001101
0011101100011101000100110011010110011101000001010011011100011001
0000110100001101001110111011111100111011100000111011110101010111
0000000100010101000001011011000100011011000011110011111100100011
0000001100111001000011110010001100111011100111110011101100100111
0011001100000011100111010011001100010011100111110011010100100001
0000110100010101100111010001100100000011001110111011110100010111
0000110110011111001101010010000100110011000011010001010100111001
0011101100011101000100110011010110011101000001010011011100011001
0001001100010101001110111010001110011101000011010010011100111101
0001011110010001001110111011111110011101010011110011011100011011
0011101110101011100111010010111100101111000000010001011100011011
1000001110000001000011111001010100110101001101110001110110001011
0000001100110111000000110011101110101111100000110001110100101111
0011010110000011000110110010000100110111000110010010101100110101
0001100100110101000001110001100100000111100000010011111100100111
1011011110000001010111111000110110000011000100011001100110001101
0110001100001011101100111001010100001001101110010110101100001111
1011000100011011101111011001010110000011101011111001010110010101
0001001110000011100111011010010110101101100000110010100100011111
0000011100010101110111011111111110000111010111010010000100100001
===========================3=============================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==========================END============================

I've followed the code the effectuator provided as well but can't get a readable answer.

Also the link I posted earlier in this thread for my decoder is working with the above code, and the bug with the copy result to clipboard button is fixed finally. I'm such a spaz sometimes.

Basicly the code says:

m = message
k = key
result = {blank}
[loop1]
c = first 64 binary digits of m
m = m with the first 64 bits knocked off
if c is less than 64 bits long then add 0s to the right until it is at least 64 bits long
in c make all the 1s 0s, and all the 0s 1s.
b1 = first 32 bits of c
b2 = last 32 bits of c
k1 = first 32 bits of k
k2 = last 32 bits of k
for every second bit in b1 (starting at 0) if it is a 1 or the same place in k1 is a 1, but they are not both 1s then replace the b1 bit with a 1, otherwise make it a 0. Leave all the other bits in b1 alone.
do the same for b2 and k2.
result = result with the rightmost bit of b1 and b2 and the rest of b1 added on to the end of it
go back to [loop1] unless m is empty
display result

... just so everybody can see where my workings are at