# The Gold Bug puzzle (DEF CON 28) The Gold Bug is an annual DEF CON puzzle hunt, focused on cryptography, run by the Crypto & Privacy Village. * [Puzzle BBS](https://goldbug.cryptovillage.org/) * [Hints on Twitter](https://twitter.com/search?q=%23TheGoldBug%20%40CryptoVillage&src=typed_query) # Quarantine Confusion > Nothing special here - just a basic crossword. [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_001-Quarantine_Confusion.pdf) We are given a crossword puzzle. ![](https://i.imgur.com/sc0zi6N.png) Note that there are numbers to the right of each clue, along with a series of numbers at the bottom. The number of numbers at the bottom matches the number of clues in the puzzle so it seems each number may correspond to one clue in some way. If we try filling in words in the crossword puzzle, we notice the intersection areas don't match up. For example, using `GEM` for 5-down and `SPORE` for 8-across leads to a conflict between `E` and `R` in the overlapping area. A different approach seems to be needed. Note the challenge description seems to state this to be a **basic** crossword. Through experimentation, we find that interpreting the answer word as some base number and converting it to the base of the number written to the right of the clue gives us a new word in English. We can find the new English words for all clues and fill out the puzzle, finding the base number we are interpreting the initial answer word as via brute-force using [online base conversion tool](https://www.rapidtables.com/convert/number/base-converter.html) or scripts to speed up the process. The final solved puzzle looks as below: ![](https://i.imgur.com/Rvw1U8L.png) Here are the initial words and the new words, along with the base numbers that they were interpreted as/converted to: ``` ACROSS 3: SAP 36 => ACED 15 4: CRUS 32 => FILM 30 6: DORK 29 => BANK 31 8: SPORE 34 => PLACE 35 9: CASHES 34 => GLOUTS 32 11: KEEN 25 => BRAN 30 12: ADDED 18 => SPIT 34 14: HOGS 34 => EXES 36 15: GOGO 29 => BEAD 33 DOWN 1: BRAN 30 => KEEN 25 2: POOS 29 => DILL 36 3: BEE 28 => ALB 29 5: GEM 27 => MIC 23 7: TRAP 30 => KILN 34 8: ROWS 34 => PETS 35 9: JOKE 30 => GALE 32 10: PLACE 35 => SPORE 34 11: DAB 14 => BEE 15 13: RACY 36 => TOAD 35 ``` Now we need to work with the numbers at the bottom of the puzzle: ``` 19,28,32,34,7,7,13,0,29,0,2,28,29,26,13,22,14,20,33 ``` Given that the number of numbers at the bottom match the number of clues, it seems each number would correspond to a number in the clue. Note that we haven't used the base numbers used to interpret the initial words that we found via trial/error anywhere: ``` 36,32,29,34,34,25,18,34,29,30,29,28,27,30,34,30,35,14,36 ``` Interpreting both as base 36, and finding the differences gives us some plaintext in leetspeak - `H4X0RI5Y0UR0Y4L8LU3`: ```python import string a = [36,32,29,34,34,25,18,34,29,30,29,28,27,30,34,30,35,14,36] b = [19,28,32,34,7,7,13,0,29,0,2,28,29,26,13,22,14,20,33] f = '' s = string.digits + string.ascii_uppercase for i in range(len(a)): f += s[(a[i]-b[i])%36] print(f) # H4X0RI5Y0UR0Y4L8LU3 ``` The answer to the challenge seems to be `royalblue` which works! Solution: `royalblue` # Computer Lab > The virology lab is having trouble keeping its samples straight. It seems the swabs have been swapped. [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_002-Computer_Lab.pdf) We are given 4 different groups of text. ![](https://i.imgur.com/ogoPzdW.png) Starting with the 1st group of words, we find that they seem to be words that represent well-known computer malware, so we can fill them in: ``` STU_N_T -> STUXNET _RYP_OLOCKER -> CRYPTOLOCKER __OVEYOU -> ILOVEYOU MY__OM -> MYDOOM ANNA _OURNIKO_A -> ANNA KOURNIKOVA EX_LORE_IP -> EXPLOREZIP S_L SL_MMER -> SQL SLIMMER PS__0T -> PSYBOT _AN_ACRY -> WANNACRY _ER_SALEM -> JERUSALEM T_ANATO_ -> THANATOS TO_PI_ -> TORPIG _LA_E -> FLAME ``` The second and third group of words don't seem to represent any known English words however. We can decrypt the fourth group using [quipqiup](quipqiup.com). Ciphertext: ``` FBQZ! SBZI B TSBQZIQ DMMZ BS GMPQ XMQZ BJL HEJL AEYQBOT SBZIJ EJ SFQIIT. ``` Plaintext: ``` HARK! TAKE A STARKER LOOK AT YOUR WORK AND FIND BIGRAMS TAKEN IN THREES. ``` If we look into the substitution mappings, we can notice they are in pairs: ``` A-B C-V D-L E-I F-H G-Y J-N K-Z M-O P-U Q-R S-T W-X ``` Perhaps the pair of letters filled in from each row from the first group serve as substitution mappings to decrypt the second group? Based on the substitution mappings of the first group (missing letters from each row): ``` X-E C-T I-L D-O K-V P-Z Q-A Y-B W-N J-U H-S R-G F-M ``` We can decrypt the second group of words!: ``` T_BZC_IDRB -> C_YPT_LOGY _DDIX_W IDRLT -> _OOLE_N LOGIC HB_YD_ -> SY_BO_ _L_XWXGX -> _I_ENERE _G_ZCDH -> _R_PTOS Z_R_XW -> P_G_EN GQLI_XWT_ -> RAIL_ENC_ _D_LQT -> _O_IAC _QKQ_D -> _AVA_O TLZ_XGCX_C -> CIP_ERTE_T __QOGQCLT HLXKX -> __ADRATIC SIEVE XIILZ_L_ TJGKX -> ELLIP_I_ CURVE ZQ_H_DGO -> PA_S_ORD ``` These seem to be words based on cryptography. We can fill in the missing letters: ``` C_YPT_LOGY -> CRYPTOLOGY _OOLE_N LOGIC -> BOOLEAN LOGIC SY_BO_ -> SYMBOL _I_ENERE -> VIGENERE _R_PTOS -> KRYPTOS P_G_EN -> PIGPEN RAIL_ENC_ -> RAILFENCE _O_IAC -> ZODIAC _AVA_O -> NAVAJO CIP_ERTE_T -> CIPHERTEXT __ADRATIC SIEVE -> QUADRATIC SIEVE ELLIP_I_ CURVE -> ELLIPTIC CURVE PA_S_ORD -> PASSWORD ``` Similar to how we decrypted the ciphertexts in the second group, we can use the substitution mappings from the second group to decrypt the third group of words. Substitution mapping for the second group (missing letters from each line): ``` R-O B-A M-L V-G K-Y I-P F-E Z-D N-J H-X Q-U T-C S-W ``` Decrypting the third group of words gives us: ``` WB_P_BLB -> SA_I_AMA _Q_LBMB -> _U_MALA W_QCXB_ICRJ -> S_UTHA_PTON ABOLB__ROFWC -> BARMA__OREST _P_B -> _I_A CR__QF CFJR -> TO__UE TENO YQJ_P_ -> KUN_I_ TR_IR_ -> CO_PO_ _BJJ_ -> _ANN_ _BT_PJPB -> _AC_INIA QQYQJP_L_ -> UUKUNI_M_ _RO_WZBMF -> _OR_SDALE _R_TBJB -> _O_CANA ``` These seem to be words based on human viruses. We can fill in the missing letters: ``` SA_I_AMA -> SAGIYAMA _U_MALA -> PUUMALA S_UTHA_PTON -> SOUTHAMPTON BARMA__OREST -> BARMAHFOREST _I_A -> ZIKA TO__UE TENO -> TORQUE TENO KUN_I_ -> KUNJIN CO_PO_ -> COWPOX _ANN_ -> BANNA _AC_INIA -> VACCINIA UUKUNI_M_ -> UUKUNIEMI _OR_SDALE -> LORDSDALE _O_CANA -> TOSCANA ``` Finally, getting the substitution mapping from the third group gives us: ``` G-Y P-U O-M H-F Z-K R-Q J-N W-X B-A V-C E-I L-D T-S ``` This matches the substitution mappings from the fourth group! So it seems the intended solution was to use these to decrypt the fourth group ciphertext. *Comment from puzzle setter: Exactly!* Going back to what the fourth group ciphertext decrypted to: ``` HARK! TAKE A STARKER LOOK AT YOUR WORK AND FIND BIGRAMS TAKEN IN THREES. ``` We need to look back at our work and find bigrams taken in threes. We use [dcode.fr's bigrams frequency analysis tool](https://www.dcode.fr/bigrams) for each of the decrypted words in the first 3 groups. Note that we should select the `by sliding/overlapping (ABCDEF => AB,BC,CD,DE,EF)` option in the Bigrams Parameters section so all bigrams in each row can be taken into account. Computing the frequencies for the 1st group of words (STUXNET, CRYPTOLOCKER, etc.), we find 5 bigrams that appear 3 times: ``` NA 3× 2.78% TO 3× 2.78% LO 3× 2.78% ER 3× 2.78% AN 3× 2.78% ``` For the 2nd group of words (CRYPTOLOGY, BOOLEAN LOGIC, etc.), we find 4 bigrams that appear 3 times: ``` OL 3× 2.63% PT 3× 2.63% IC 3× 2.63% EN 3× 2.63% ``` For the 3rd group of words (SAGIYAMA, PUUMALA, etc.), we find 3 bigrams that appear 3 times: ``` MA 3× 2.97% OR 3× 2.97% TO 3× 2.97% ``` For the 4th group of words (HARK! TAKE A...THREES), we find 3 bigrams that appear 3 times: ``` TA 3× 5.36% KE 3× 5.36% RK 3× 5.36% ``` Observing all the bigrams that appear 3 times together: ``` 1st group: NA TO LO ER AN 2nd group: OL PT IC EN 3rd group: MA OR TO 4th group: TA KE RK ``` Note that we may be able to form a word by taking one bigram from each group. We can get `TO` from the 1st group, `OL` from the 2nd group, `MA` from the 3rd group, and `RK` from the 4th group to spell `TOOLMARK`. Submitting this as the answer works! Solution: `toolmark` # Prime Time > Unfortunately, the order is a bit off. [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_003-Prime_Time.pdf) We are given a large number and the prime factorization of a number: ![](https://i.imgur.com/ELTDkNJ.png) Factoring the large number `14697688090486313344041676760459967385` using [factordb](factordb.com), we find the number nicely factors to small prime numbers: ``` 5,37,73,103,107,109,157,181,193,239,241,293,347,353,397,431,467 ``` The following key hints were released for this challenge: * Consider your factors in order... and observe the gaps * Once you find the gaps, pull yourself together and start over * After my second factoring in the morning, I like to sort things; the order may seem arbitrary to other people, but i get excited At the Sequence of Corresponding Integer Items It seems we need to find the differences ("gaps") of the factors in order. However, since they are all primes, we may get more interesting results if we consider the position of each prime number in the prime number line. First, we need to find what number prime each prime number in the factorization is (i.e. 2 is the 1st prime, 3 is the 2nd prime, etc.): Then, we find the differences between each number. We can write a script to do this: ```python from Crypto.Util.number import * p = [5,37,73,103,107,109,157,181,193,239,241,293,347,353,397,431,467] d = dict() d[2] = 1 count = 2 for i in range(3,468,2): if isPrime(i): d[i] = count count += 1 arr = [] for num in p: arr.append(d[num]) print(arr) diffs = [] for i in range(len(arr)-1): diffs.append(arr[i+1]-arr[i]) print(diffs) ``` Running the script, we get: ``` ➜ python solve.py [3, 12, 21, 27, 28, 29, 37, 42, 44, 52, 53, 62, 69, 71, 78, 83, 91] [9, 9, 6, 1, 1, 8, 5, 2, 8, 1, 9, 7, 2, 7, 5, 8] ``` Note that if we put the numbers in the differences array together (`9961185281972758`) and try factoring, the factorization doesn't give good small factors. Since the first factor was a `5` (3rd prime number), we may need to add a `3` (`3-0 = 3`) at the start of the differences array. This gives the number `39961185281972758`. Factoring `39961185281972758`, we get the following factors: ``` 2,67,79,83,857,6577,8069 ``` Based on the hints, it seems we need to convert these to ASCII and possibly shift the factors around to a new order. Note that 67 => C, 79 => O, 83 => S, 65 => A, 77 => M, 80 => P, 69 => E if we convert the decimals to ASCII. 2 and 857 don't seem to be convertible but if we make 2 go to the end of 857, we get 8572 => 85,72 => U and H. Thus, we have the following ASCII characters: ``` C O S A M P E U H ``` Unscrambling the letters to form a word, we get `CAMPHOUSE` which works as the answer! Solution: `camphouse` *Comment from puzzle setter: The additional info `2x97x13781` was meant to signal to you the order to take the primes before converting to ASCII. `2x97x13781 = 2673514` which suggests taking the 2nd prime (`67`) then the 6th prime (`6577`), etc. That would have given you `CAMPEOUHS` which was still a bit off from `CAMPHOUSE`.* # Germs Can't Catch Me > Who am I? Where am I? How deep do I go? > PSA: Please remember there is at least one R in quaRantine: > Run, Read, Rotate, and Relax... in some order. > And don't forget to wash your hands! [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_004-Germs_Cant_Catch_Me.pdf) We are given a base64 encoded string: ![](https://i.imgur.com/tzFCjus.png) Decoding it as a file, we find that we get a gzip archive: ``` ➜ echo H4sIAMYNIV8C/21Q0RICIQj8Npkxu246Czv+/1NiCQybHkSB3RV2yMZ3rjToWlleZxtauPDGpd1obejjgWBdwKiwoWXHVaRwcDwFWktITSJJdhTbWdlAB4KjA/G0v2RPmr/3Iqq5qWTdKMTBMHlRzRP9mLsnbM+z/DOnT2r8SIsRTnO5sIXn/OZr0nPDvjt8yNF200MH6nkjnDc0wV8B1AEAAA== | base64 -d > dec ➜ file dec dec: gzip compressed data, last modified: Wed Jul 29 05:48:54 2020, max compression, original size modulo 2^32 468 ``` Extracting the gzip archive, we find there is a text file containing some ciphertext: ``` ➜ 7z e dec ➜ cat dec~ SVIRMREBSBHERVTUGSVIRFRIRAGJBMREBSBHERVTUGSBHEPSBHEFRIRASVIRBARSVIRFVKSVIRAVARGJBMREBSVIRAVARSBHEGJBSVIRRVTUGGJBMREBSBHEOSVIRGUERRSBHENSBHESBHEGJBMREBSBHEQSBHEFVKGJBMREBSVIRMREBSVIRMREBSVIRRVTUGGJBMREBSVIRSBHESVIRGUERRSBHESBHESVIRSVIRSVIRGJBSBHERVTUGSVIRGJBGJBMREBSVIRNSVIRFRIRASVIRGJBSBHEOSBHEQSBHEFVKSVIRFRIRAGJBMREBSBHEOSVIRNSVIRSBHESBHEBARGJBMREBSVIRFVKSVIRGJBSBHEAVARSBHERSVIRRVTUGSBHEPGJBMREBSBHEGJBSVIRGUERRSBHESVIRGJBMREBSBHEBARSVIRAVARSBHEFVKSBHERVTUGSVIRSVIR ``` Decoding the ciphertext as ROT-13, we get the plaintext: ``` FIVEZEROFOUREIGHTFIVESEVENTWOZEROFOUREIGHTFOURCFOURSEVENFIVEONEFIVESIXFIVENINETWOZEROFIVENINEFOURTWOFIVEEIGHTTWOZEROFOURBFIVETHREEFOURAFOURFOURTWOZEROFOURDFOURSIXTWOZEROFIVEZEROFIVEZEROFIVEEIGHTTWOZEROFIVEFOURFIVETHREEFOURFOURFIVEFIVEFIVETWOFOUREIGHTFIVETWOTWOZEROFIVEAFIVESEVENFIVETWOFOURBFOURDFOURSIXFIVESEVENTWOZEROFOURBFIVEAFIVEFOURFOURONETWOZEROFIVESIXFIVETWOFOURNINEFOUREFIVEEIGHTFOURCTWOZEROFOURTWOFIVETHREEFOURFIVETWOZEROFOURONEFIVENINEFOURSIXFOUREIGHTFIVEFIVE ``` This seems to be numbers explicitly written out. We can convert this to numeric form: ``` ➜ python Python 3.8.5 (default, Jul 27 2020, 08:42:51) [GCC 10.1.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> 'FIVEZEROFOUREIGHTFIVESEVENTWOZEROFOUREIGHTFOURCFOURSEVENFIVEONEFIVESIXFIVENINETWOZEROFIVENINEFOURTWOFIVEEIGHTTWOZEROFOURBFIVETHREEFOURAFOURFOURTWOZEROFOURDFOURSIXTWOZEROFIVEZEROFIVEZEROFIVEEIGHTTWOZEROFIVEFOURFIVETHREEFOURFOURFIVEFIVEFIVETWOFOUREIGHTFIVETWOTWOZEROFIVEAFIVESEVENFIVETWOFOURBFOURDFOURSIXFIVESEVENTWOZEROFOURBFIVEAFIVEFOURFOURONETWOZEROFIVESIXFIVETWOFOURNINEFOUREFIVEEIGHTFOURCTWOZEROFOURTWOFIVETHREEFOURFIVETWOZEROFOURONEFIVENINEFOURSIXFOUREIGHTFIVEFIVE'.replace('ONE','1').replace('TWO','2').replace('THREE','3').replace('FOUR','4').replace('FIVE','5').replace('SIX','6').replace('SEVEN','7').replace('EIGHT','8').replace('NINE','9').replace('ZERO','0') '50485720484C4751565920594258204B534A44204D46205050582054534455524852205A57524B4D4657204B5A5441205652494E584C20425345204159464855' ``` Given that there are non-digit characters such as `A`,`B`, etc. in the number, it seems to be a hex string. Decoding the string as hex, we find another ciphertext: ``` >>> bytearray.fromhex('50485720484C4751565920594258204B534A44204D46205050582054534455524852205A57524B4D4657204B5A5441205652494E584C20425345204159464855').decode() 'PHW HLGQVY YBX KSJD MF PPX TSDURHR ZWRKMFW KZTA VRINXL BSE AYFHU' ``` We can decrypt this ciphertext using the Vigenere cipher, finding the key through trial and error based on the resulting plaintext using [Cryptii's online decoder](https://cryptii.com/pipes/vigenere-cipher). If we assume the plaintext for `PHW` is `THE`, we get the key `was`. We can assume the next characters may be `washyourhands` based on the challenge description. Through further deduction, we can recover the entire key to be `washyourhandsoftenwithsoapandwaterforatleasttwentyseconds`, and the resulting plaintext: ``` THE ANSWER YOU SEEK IS THE MAPUCHE WARRIOR WITH KNIVES FOR HANDS ``` Googling "mapuche warrior with knives for hands", we find the answer that we want to be `Galvarino`. Solution: `galvarino` # The Secret Life > Be careful, the third rail is life [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_005-The_Secret_Life.pdf) We are given 3 different graphics that look like DNA. ![](https://i.imgur.com/HKcroMw.png) Notice that there seems to be 6 different colors used total for all the rectangles in each graphic: ``` light-blue mid-blue dark-blue light-green mid-green dark-green ``` We can open the PDF in GIMP and using the Color Picker tool, find the hex color codes for each color: ``` light-blue #7fffd4 mid-blue #40e0d0 dark-blue #008080 light-green #adff2f mid-green #7fff00 dark-green #008000 ``` Based on the color codes, we can find the names for each color: ``` light-blue #7fffd4 - Aquamarine mid-blue #40e0d0 - Turquoise dark-blue #008080 - Teal light-green #adff2f - GreenYellow mid-green #7fff00 - Chartreuse dark-green #008000 - Green ``` Note that each of the color names start with either A,T,G,C, the symbols for the 4 bases used in DNA codons. We can convert the 3 graphics to represent codons based on the colors: ``` AGT CTT GAA TGT ACT GAG ATC CCT GAA GAG GAC GAA CGA TTC AAT AAC ATG AAC CTA GCA ATA ``` Converting the codons to alphabetic form based on [DNA codon table](https://en.wikipedia.org/wiki/DNA_codon_table), we get: ``` SLECTEI PEEDERF NNMNLAI ``` The challenge description seems to hint at usage of [railfence cipher](http://rumkin.com/tools/cipher/railfence.php). Decrypting `SLECTEIPEEDERFNNMNLAI` with the railfence cipher using 3 rails, we get plaintext!: ``` SIMPLENEEDLECRAFTNINE ``` `SIMPLE NEEDLE CRAFT NINE` seems to imply that the answer to this challenge is a 9-letter word that means "simple needlecraft". We can use tools such as [OneLook](https://onelook.com/) to find such words and submit to BBS until we find our desired answer: `plainwork`. Solution: `plainwork` *Comment from puzzle setter: Many folks were thrown by a red herring in the visual, specifically the size of the dots. This was initially intended to be a repeated pattern (if you tesselate the pattern, it repeats smnoothly), but we didn't end up using it that way. Also, this flag was particularly hard to find - looking up the flag gave a clear definition, but searching `simple needlecraft` did not yield this word.* # Infected (Meta) > This is a meta puzzle - it solves the overall Goldbug puzzle hunt once you have the other solutions. It will be hard to complete without the other puzzle solutions. [Challenge PDF](https://bbs.goldbug.cryptovillage.org/puzzles/CPV_28-Gold_Bug_Meta-Infected.pdf) We are given the following ciphertext: ![](https://i.imgur.com/iIOzgc0.png) We can convert these characters to alphabetic form using a Python script: ```python import string s = "?*1|(;?*5;80: :|?'q8 3|;;8* )6-7 ]4608 )|0q6*3 ;48)8 .?[[08). :|?'(8 )| *5?)8|?), :|? ;4(|] ?. ;]6-8 (8]!). :|?'(8 ,?); 0?-7: 6;') 5*|;48( q6(?), *|; -|q6+-19." alphabet = string.ascii_uppercase idx = 0 d = dict() for c in s: if c == " ": continue else: if c not in d: d[c] = alphabet[idx] idx += 1 ctxt = '' for c in s: if c == " ": ctxt += " " else: ctxt += d[c] print(ctxt) ``` This gives us: > ABCDEFABGFHIJ JDAKLH MDFFHB NOPQ RSOIH NDILOBM FSHNH TAUUIHNT JDAKEH ND BGANHDANV JDA FSEDR AT FROPH EHRWNT JDAKEH VANF IAPQJ OFKN GBDFSHE LOEANV BDF PDLOXPCYT > *Comment from puzzle setter: This is the [Gold Bug cipher](https://en.wikipedia.org/wiki/The_Gold-Bug#The_cryptogram)! You didn't need to perform cryptographic analysis to decode this.* Now we can use [quipqiup](quipqiup.com) to decrypt the ciphertext (taking into account punctuation): > UNFORTUNATELY YOU'VE GOTTEN SICK WHILE SOLVING THESE PUZZLES. YOU'RE SO NAUSEOUS, YOU THROW UP TWICE (EW!). YOU'RE JUST LUCKY IT'S ANOTHER VIRUS, NOT COVID-19. It seems the answer to this puzzle is related to a human virus. Given this is the meta puzzle, we may need to use the answers from the prior puzzle to help find the answer for this challenge: * QUA: `royalblue` * COM: `toolmark` * PRI: `camphouse` * GER: `galvarino` * SEC: `plainwork` If we interpret each answer as an anagram, using [online anagram solver](http://www.wordfinders.com/), we notice we can find virus-related words for `royalblue` and `galvarino`. * `royalblue`: `rubella` (`oy` left) * `galvarino`: `variola` (`ng` left) To find the virus-related words hidden in the remaining answers, we use [ViralZone's human viruses table](https://viralzone.expasy.org/678) for a list of virus names: * `plainwork`: `norwalk` (`pi` left) * `toolmark`: `mokola` (`tr` left) * `camphouse`: `machupo` (`se` left) Now, taking all of the remaining letters (`oy`,`ng`,`pi`,`tr`,`se`), we try using these as an anagram and solving for a word. Using online anagram solver, we get the word `serotyping` which seems to be a virus-related word. Submitting this as the answer works! Solution: `serotyping`