We Are A Highly Technical Society. Our Everyday Lives Revolv ✓ Solved

We are a highly technical society. Our everyday lives revolv

We are a highly technical society. Our everyday lives revolve around the Internet: we benefit from the Internet, but we can also be victims of cyber criminals. To understand how criminals use the Internet to their advantage, one must understand how we communicate on the Internet. In this paper, you are required to describe in detail how we communicate on the Internet, based upon your readings. Discuss the major networking building blocks and their functions. Secondly, discuss software applications' vulnerabilities, such as those found in web browsers.

Paper For Above Instructions

Introduction

The Internet is a globally distributed system that enables billions of devices to exchange information. Understanding how communication occurs across this system requires a layered view of protocols and network building blocks that transform user intent into reliable data exchange. Equally important is recognizing that software at the endpoints — notably web browsers and other applications — introduce vulnerabilities that attackers exploit. This paper outlines how we communicate on the Internet, describes key networking components and their functions, and summarizes common application-layer vulnerabilities with mitigation considerations (Kurose and Ross 2017; Tanenbaum and Wetherall 2011).

How Communication Works: Layered Principles

Internet communication follows a layered architecture (commonly modeled as TCP/IP or OSI layers) where each layer provides services to the one above and relies on the one below. The application layer includes protocols such as HTTP, SMTP, and DNS that define data formats and application semantics (Fielding et al. 1999). The transport layer (TCP/UDP) provides end-to-end logical communication: TCP offers reliable, ordered delivery, congestion control, and flow control; UDP offers lightweight, connectionless datagrams for latency-sensitive applications (RFC 793; RFC 768). The network layer (IP) handles addressing and routing of packets across heterogeneous networks (RFC 791). Beneath IP, the link and physical layers define how frames are transmitted over media (Ethernet, Wi-Fi) and how bits are encoded on physical channels (Kurose and Ross 2017).

Major Networking Building Blocks and Their Functions

Several infrastructure elements make Internet communication practical and scalable.

  • Hosts and Endpoints: Devices (clients and servers) that originate and consume data. They implement application and transport protocols (Kurose and Ross 2017).
  • Switches: Operate at the link layer to forward frames based on MAC addresses inside local networks; they enable efficient LAN segmentation and reduce collision domains (Tanenbaum and Wetherall 2011).
  • Routers: Interconnect networks and forward IP packets based on routing tables and algorithms; routers implement forwarding, route discovery, and sometimes filtering (RFC 791).
  • DNS (Domain Name System): A hierarchical distributed database that maps human-friendly names to IP addresses and provides service discovery. DNS resolution is foundational for virtually all Internet applications (Mockapetris 1987).
  • Firewalls and NAT (Network Address Translation): Firewalls filter traffic according to policy; NAT translates private to public addresses to conserve IPv4 space and add a degree of host isolation (Kurose and Ross 2017).
  • Content Delivery Networks (CDNs) and Load Balancers: CDNs cache content at edge locations for performance and scalability; load balancers distribute requests across server pools to provide availability (Kurose and Ross 2017).
  • Proxies and Gateways: Intermediary systems that perform caching, protocol translation, inspection, or anonymization. They influence performance, privacy, and security behavior of client-server interactions.

These components work together via standardized protocols so that a browser request (e.g., HTTP GET) becomes a sequence of DNS resolution, TCP handshake, IP routing across routers, possible NAT traversal, and delivery to the server; the server response traverses the reverse path (Fielding et al. 1999; RFC 793).

Software Applications and Browser Vulnerabilities

While network infrastructure can provide defensive measures, application-layer software introduces many attack vectors. Web browsers, as the primary user interface to the web, are particularly attractive targets. Common browser and web-application vulnerabilities include:

  • Cross-Site Scripting (XSS): When applications reflect or store untrusted input without proper output encoding, attackers can inject scripts that execute in victims' browsers, stealing cookies or session tokens (OWASP 2021).
  • Cross-Site Request Forgery (CSRF): Attackers induce authenticated users to perform unintended actions by exploiting the browser’s tendency to include credentials (cookies) automatically in requests (OWASP 2021).
  • Insecure Direct Object References and Broken Access Controls: Misconfigured server logic or insufficient authorization checks permit unauthorized resource access (OWASP 2021).
  • Same-Origin Policy (SOP) Bypasses: The SOP is a cornerstone of browser security, but complex interaction with plugins, extensions, or misconfigured CORS headers can create bypasses and data leaks (MDN 2020).
  • Outdated Components and Plugins: Third-party libraries, browser plugins, and extensions often contain unpatched vulnerabilities that give attackers code-execution or data-exfiltration opportunities (Verizon 2021).
  • Buffer Overflows and Memory Safety Issues: Native components (e.g., media decoders) can be exploited via crafted inputs, leading to remote code execution in the browser process (Tanenbaum and Wetherall 2011).
  • Phishing and Social Engineering via Web Interfaces: Malicious pages mimic legitimate sites to harvest credentials or trick users into installing malware (Verizon 2021).

These vulnerabilities are routinely cataloged in the OWASP Top Ten and tracked by vulnerability databases such as MITRE’s CVE list (OWASP 2021; MITRE 2021). Attackers often chain weaknesses (e.g., XSS to session hijacking to privilege escalation) to achieve broader compromise.

Implications and Defenses

Mitigations combine robust software engineering, protocol-level safeguards, and network defenses. At the application level, input validation, output encoding, secure session management, and use of modern security headers (Content-Security-Policy, Strict-Transport-Security) reduce web attack surfaces (OWASP 2021; MDN 2020). At the transport and network layers, encryption (TLS) protects confidentiality and integrity of data in transit; secure configuration of routers, firewalls, and DNS resolvers prevents many routing and name-service attacks (Kurose and Ross 2017).

Operational practices such as timely patching of browser engines and third-party components, least-privilege policies, threat monitoring, and use of Content Delivery Networks and web application firewalls provide additional layers of defense (NIST 2014; Verizon 2021). Defense-in-depth, combining secure coding, hardened endpoints, and resilient network architecture, is the most resilient posture against attackers who exploit both network and application weaknesses.

Conclusion

Understanding how we communicate on the Internet requires an appreciation of layered protocols and the network building blocks — hosts, switches, routers, DNS, NAT, and intermediaries — that convert user requests into packets traversing global infrastructure. Web browsers and other application software introduce vulnerabilities that attackers exploit, so securing the Internet depends on both robust network design and disciplined application security practices. Combining standards-based protocols, encryption, secure software development, and operational controls yields the best protection against the myriad threats facing modern Internet users (Kurose and Ross 2017; OWASP 2021; NIST 2014).

References

  • Kurose, James F., and Keith W. Ross. 2017. Computer Networking: A Top-Down Approach. 7th ed. Boston: Pearson.
  • Tanenbaum, Andrew S., and David J. Wetherall. 2011. Computer Networks. 5th ed. Upper Saddle River, NJ: Prentice Hall.
  • Postel, Jon. 1981. RFC 791 — Internet Protocol. RFC 791. https://tools.ietf.org/html/rfc791.
  • Postel, Jon. 1981. RFC 793 — Transmission Control Protocol. RFC 793. https://tools.ietf.org/html/rfc793.
  • Mockapetris, Paul. 1987. RFC 1035 — Domain Names — Implementation and Specification. RFC 1035. https://tools.ietf.org/html/rfc1035.
  • Fielding, Roy, et al. 1999. RFC 2616 — Hypertext Transfer Protocol -- HTTP/1.1. RFC 2616. https://tools.ietf.org/html/rfc2616.
  • OWASP Foundation. 2021. OWASP Top Ten 2021. https://owasp.org/Top10/.
  • MDN Web Docs (Mozilla). 2020. “Same-Origin Policy” and Web Security Guidelines. https://developer.mozilla.org/.
  • NIST. 2014. NIST Special Publication 800-53: Security and Privacy Controls for Federal Information Systems and Organizations. National Institute of Standards and Technology. https://csrc.nist.gov/publications/detail/sp/800-53/rev-4/final.
  • Verizon. 2021. Data Breach Investigations Report (DBIR) 2021. https://www.verizon.com/business/resources/reports/dbir/.
  • MITRE. 2021. CVE - Common Vulnerabilities and Exposures. https://cve.mitre.org/.

Related Assignments