We're given a schematic and 4 pieces of code. The schematic has 5 logic gates, 3 network ports, and 3 circles. The lines (or traces) all have unique colors. Two of the colored traces on the schematic are pre-labeled: Brown is "I" and Red is "O". (This is I and O, not 1 and 0). This suggests what we're doing in this puzzle is labeling the rest of the colors with the appropriate letters.
Each source file is by "roy g biv." This is a reference to the colors of the rainbow, which clues us into seeing colors in these files. Indeed we find 3-byte sequences throughout the file, and specifically these are in lowercase just like the author's name (defying convention). Reassigning these hex values to colors allows us to match up lines of code to the schematic and results.
We also notice, conspicuously, that the file name extension of the source file is missing. Each file is written in a different programming language, created on the date in the header comment. Each language also uses a 2-letter file extension:
The source code files are numbered 1–3 and are text on a black background. This corresponds to the numbered circles in the schematic. Since these are black circles (dots) and have an arrow indicating direction, we make the leap to assign the incoming color to the first letter, and the outgoing color to the second letter. This is confirmed by the red trace being assigned O again.
The first part of each file, using simplified code, opens sockets to different ports. We recognize that the ports used in these tests: 21, 25, and 80 are all well-known ports assigned to the protocols FTP, SMTP, and HTTP respectively. The operation is to send a color to the indicated port (this selects which RJ port on the schematic is being referenced).
Looking at the comments, we see the acrostic RFC, which, in network lingo, refers to "Requests for Comments", which are the published specifications of these protocols. In case we miss the acrostic, the third line is explicitly "requesting a comment".
Looking up the RFC numbers for each protocol, we get a few possibilities, but the date on the first comment disambiguates which RFC is correct (and confirms that this is the right thing to be looking at). Additionally, that RFC number is close to the "expected" value being asserted. We take the difference, and use "code page 38" (ASCII) to assign a letter.
| WKP | Protocol | Asserted | RFC | Date | Difference | Color | Letter |
|---|---|---|---|---|---|---|---|
| 21 | FTP | 179 | 114 | April 1971 | 65 | 3cb44b | A |
| 25 | SMTP | 861 | 788 | November 1981 | 73 | 9a6324 | I |
| 80 | HTTP | 2029 | 1945 | May 1996 | 84 | fabed4 | T |
The remaining pieces of the code have a similar structure, but instead we're writing values "to" the colored traces. These colors are the inputs to the logic gates in the schematic. Rather than page 38, we're using page 37: IBM EBCDIC (non-ASCII). The "wrong value" also includes the bytes 0xEBCD1C. In total, 4 bytes are sent into each gate, which translate to a 4-letter word. The 4-letter word is a clue to another word that contains the gate between 3 letters. As a confirmer, OR gates are compared to wrong values that are 5 bytes (letters) long, while AND gates are compared to wrong values that are 6 bytes (letters) long.
For example, the snippet in test1 sends 0xD3D6 (LO) and 0xE5C5 (VE) to the gate with input colors 0x3cb44b (green) and 0x4363d8 (blue), and output color 0x469990 (teal), which is the upper left OR gate. The answer to this gate is AD(OR)E, confirming our earlier letter assignment of A to green, and additionally assigning D to blue and E to teal.
| Bytes | Word | Gate Word | Color 1 | Color 2 | Color 3 | |
|---|---|---|---|---|---|---|
| test1 | 0xD3D6, 0xE5C5 | LOVE | AD(OR)E | 3cb44b (A) | 4363d8 (D) | 469990 (E) |
| test2 | 0xC7C9, 0xD3C4 | GILD | AD(OR)N | 3cb44b (A) | 4363d8 (D) | dbceff (N) |
| 0xE6C9, 0xD5C5 | WINE | BR(AND)Y | 42d4f4 (B) | f58231 (R) | fffac8 (Y) | |
| test3 | 0xE2, 0xC9, 0xE9, 0xC5 | SIZE | GR(AND)E | 800000 (G) | f58231 (R) | 469990 (E) |
| 0xC2, 0xD6, 0xD5, 0xC5 | BONE | IV(OR)Y | 9a6324 (I) | ffe119 (V) | fffac8 (Y) |
Putting together all the pieces, we get this final table of colors. As a final confirmer, the letters are in alphabetical order by hex value:
| Color | Hex | Letter |
|---|---|---|
| green | 3cb44b | A |
| cyan | 42d4f4 | B |
| blue | 4363d8 | D |
| teal | 469990 | E |
| maroon | 800000 | G |
| brown | 9a6324 | I |
| lavender | dbceff | N |
| red | e6194b | O |
| magenta | f032e6 | P |
| orange | f58231 | R |
| pink | fabed4 | T |
| yellow | ffe119 | V |
| light yellow | fffac8 | Y |
The last file is a Kotlin file, with the appropriate date and by the same author. Here, we're using the discriminator array to get the desired value. We're given 2 lines that perform an "exorbitant hash", which clues performing the XOR operation. The first line in "inputs" gives 136 / 0x88 / 10001000, which is suspicious; more suspicious is the "outputs" value of 32 / 0x20 / 00100000.
Inspecting these lines, we see that the parameters to the hash function are the RGB values, the ASCII value and this new discriminator value. How do we choose which index to use in the discriminator array? The array is 26 values long, and we used the 9th value (0-based index 8) for the color 9a6324 with letter I, the 9th letter of the alphabet.
Computing the values, we get the following table:
| Color | Hex | ASCII | Discriminator | Dec. XOR | Bin. XOR | Letter | ||
|---|---|---|---|---|---|---|---|---|
| green | 0x3c | 0xb4 | 0x4b | 0x41 | 0x82 | 0 | 00000000 | A |
| cyan | 0x42 | 0xd4 | 0xf4 | 0x42 | 0x20 | 0 | 00000000 | B |
| blue | 0x43 | 0x63 | 0xd8 | 0x44 | 0xb8 | 4 | 00000100 | D |
| teal | 0x46 | 0x99 | 0x90 | 0x45 | 0x18 | 18 | 00010010 | E |
| maroon | 0x80 | 0x00 | 0x00 | 0x47 | 0xc7 | 0 | 00000000 | G |
| brown | 0x9a | 0x63 | 0x24 | 0x49 | 0x1c | 136 | 10001000 | I |
| lavender | 0xdb | 0xce | 0xff | 0x4E | 0xe0 | 68 | 01000100 | N |
| red | 0xe6 | 0x19 | 0x4b | 0x4F | 0xdb | 32 | 00100000 | O |
| magenta | 0xf0 | 0x32 | 0xe6 | 0x50 | 0xf4 | 128 | 10000000 | P |
| orange | 0xf5 | 0x82 | 0x31 | 0x52 | 0x5d | 73 | 01001001 | R |
| pink | 0xfa | 0xbe | 0xd4 | 0x54 | 0xe5 | 33 | 00100001 | T |
| yellow | 0xff | 0xe1 | 0x19 | 0x56 | 0x41 | 16 | 00010000 | V |
| light yellow | 0xff | 0xfa | 0xc8 | 0x59 | 0x94 | 0 | 00000000 | Y |
In binary, we see that some letters are 0's, and that the number of 1 bits is very low. The binary representations indicate which positions the letter appears in an 8-letter sequence. There are only 2 reasonable words that can be made from the regular expression [ip][nr][ot][ev][ir][dn]e[rt]: the answer INTERNET PROVIDER.