An SNMPv3 manager must monitor a few legacy switches that speak only SNMPv1; what does an SNMP proxy forwarder do, and where should it sit?
answer
- a narrow meaning of proxy
- forwarding by context, not by object
- upstream and downstream versions
- what GetBulk becomes on the v1 leg
- where the community still travels
basics
~20 sAn SNMP proxy forwarder (RFC 3413) relays requests and notifications to another SNMP engine by context, without interpreting the objects; under RFC 3584 it also translates versions. Place it next to the SNMPv1 switches, because its downstream leg still carries a cleartext community.
solid answer
~50 sRFC 3413 narrows "proxy" to a **proxy forwarder application**: it forwards SNMP messages to another SNMP engine according to the **context** in them, irrespective of the managed object types, and returns the responses - it needs no detailed MIB view, unlike a command responder. Where it forwards is driven by a translation table, managed through `SNMP-PROXY-MIB` if made SNMP-manageable. RFC 3584 (BCP 74) adds version translation: a `GetBulkRequest-PDU` sent to an SNMPv1 agent goes out as a `GetNextRequest-PDU` with non-repeaters and max-repetitions treated as 0, and an SNMPv1 `Trap-PDU` comes back upstream as an `SNMPv2-Trap-PDU`, its original agent-addr and community kept in `snmpTrapAddress` and `snmpTrapCommunity`. The manager-to-proxy leg can use SNMPv3 authentication and privacy; the proxy-to-switch leg is still SNMPv1 with a cleartext community. So put the proxy as close to the legacy switches as possible, and secure it and keep it available like a manager.
go deeper
Recall that an SNMP proxy relays messages for devices the manager cannot or should not talk to directly, such as switches that speak only SNMPv1.
Explain RFC 3413's narrow definition - forwarding by context, irrespective of objects - and the RFC 3584 translations for GetBulk and v1 traps.
Place the proxy to confine the cleartext community, and plan for what it adds: a single point of failure, a credential store and slower walks on the v1 leg.
Decide when proxying legacy devices is worth running versus replacing them, weighing migration cost against a permanent component and a lasting weak leg in the design.
## What "proxy" means in SNMP RFC 3413 §1.5 notes that "proxy" has historically meant several things, and picks one: | Historical meaning | Is it RFC 3413's proxy forwarder? | |---|---| | Forwarding SNMP requests to another entity regardless of the object types, e.g. across transports or between SNMP versions | yes - the closest meaning | | Translating SNMP into some non-SNMP management protocol | no | | Aggregating objects whose values depend on several remote items | no | The rule that separates a **proxy forwarder** from an agent: a proxy forwarder forwards messages "according to the context, and irrespective of the specific managed object types being accessed", while a **command responder** processes requests per object and "must have the detailed definition of the MIB view". Implementing a proxy forwarder is optional. ## How the proxy chooses where to send things RFC 3413 §3.5 lists four classes of message a proxy forwarder handles: 1. **Read-Class and Write-Class** (Get, GetNext, GetBulk, Set): delivered to the engine "downstream in the path" to the information, chosen from the request's context; the response is carried back. 2. **Notification-Class** (SNMPv2-Trap, Inform): forwarded to the engines that should hear about that context. 3. **Response-Class**: matched to the request or notification it answers and sent back to its initiator. 4. **Internal-Class** (such as Report): likewise matched and returned. The mapping from incoming to outgoing target is implementation-specific, typically a preconfigured translation table; if that table is SNMP-manageable it must use the `SNMP-PROXY-MIB` module. For a confirmed notification, the proxy forwards the target's response when it arrives rather than answering at once, so the originator's acknowledgement still means delivery. ## Version translation for an SNMPv1-only switch RFC 3584 (Best Current Practice 74) defines the PDU translations. With an SNMPv3 manager upstream and an SNMPv1 switch downstream (RFC 3584 §4.3.1): - A `GetBulkRequest-PDU` is forwarded as a `GetNextRequest-PDU`, acting as if non-repeaters and max-repetitions were both 0 - so a bulk walk degrades to one GetNext per step on the v1 leg. - A `tooBig` response is reshaped for the newer version: for a plain request the varbinds are removed and error-index set to 0; for a translated GetBulk the proxy retries once with only the first varbind. - An SNMPv1 `Trap-PDU` is translated by RFC 3584 §3's rules and forwarded as an `SNMPv2-Trap-PDU`; the original agent-addr and community survive in `snmpTrapAddress` and `snmpTrapCommunity`. The reverse case - an SNMPv1 manager behind the proxy and a newer agent in front - has its own rules in RFC 3584 §4.3.2, mostly about hiding `Counter64` values that SNMPv1 cannot carry. A v1-only switch has no 64-bit counters to return, so high-speed interfaces on it are limited to what its 32-bit objects can show; the proxy cannot add data the device lacks. ## Where to put it, and what it costs The security picture decides placement: - **Upstream leg** (manager to proxy): SNMPv3 with authentication and privacy. - **Downstream leg** (proxy to switch): SNMPv1, whose community travels in cleartext in every request. So the proxy belongs as close to the legacy switches as possible, ideally on the same isolated management segment, so the community crosses the fewest links. It also becomes: - a **single point of failure** for monitoring those switches - plan for its loss; - a **choke point** that holds the downstream communities - harden it like a manager; - an extra hop with its own timeouts, which slows bulk walks that it has turned into GetNext steps; - a place where configuration drifts: every legacy switch's community and address lives in the proxy's translation table, and must change there when the switch changes. The proxy is a bridge, not a fix. It buys time until the legacy switches can be replaced by devices that speak SNMPv3 themselves. ## Proxy, AgentX and mid-level manager | | Proxy forwarder | AgentX master agent | Mid-level manager | |---|---|---|---| | Speaks SNMP on both sides | yes | upstream only; AgentX downstream | yes | | Interprets objects | no | dispatches by registered region | yes | | Visible to the manager | yes, as an intermediary | no - looks like one agent | yes, as an agent of its own | RFC 2741 states that transparency to managers is what differentiates AgentX subagents from SNMP proxy agents.
- What must an SNMP proxy forwarder do when an SNMPv1 manager reads a Counter64 from an SNMPv2c agent?Counter64 cannot travel in SNMPv1. Per RFC 3584 §4.3.2, a Get answer containing one becomes a `noSuchName` error with error-index at that varbind; for GetNext the proxy re-sends, stepping past Counter64 objects until none come back. Because that is expensive, the RFC suggests making Counter64 objects not-in-view for the proxy's downstream principal.
- Why not let the SNMPv3 manager speak SNMPv1 to those switches directly?Then the cleartext community crosses the whole path from the manager, and the manager must keep v1 credentials alongside its v3 users. A proxy near the switches confines the community to the last segment and lets the manager treat every device as SNMPv3, at the price of another component to run and secure.
saying these in an interview costs you the question
- An SNMP proxy forwarder checks every relayed object against its own MIB view.
- Putting a proxy in front makes the SNMPv1 switch secure end to end.
- The proxy acknowledges an inform at once, before the target confirms.
- A GetBulkRequest passes unchanged to an SNMPv1 agent through the proxy.
- An AgentX subagent is just an SNMP proxy running on the same box.