diff --git a/lib/puppet/network/http/handler.rb b/lib/puppet/network/http/handler.rb
index db12a8b67..04ba14401 100644
--- a/lib/puppet/network/http/handler.rb
+++ b/lib/puppet/network/http/handler.rb
@@ -1,176 +1,182 @@
 module Puppet::Network::HTTP
 end
 
 require 'puppet/network/http/api/v1'
 
 module Puppet::Network::HTTP::Handler
     include Puppet::Network::HTTP::API::V1
 
     attr_reader :server, :handler
 
     # Retrieve the accept header from the http request.
     def accept_header(request)
         raise NotImplementedError
     end
 
     # Which format to use when serializing our response.  Just picks
     # the first value in the accept header, at this point.
     def format_to_use(request)
         unless header = accept_header(request)
             raise ArgumentError, "An Accept header must be provided to pick the right format"
         end
 
         format = nil
         header.split(/,\s*/).each do |name|
             next unless format = Puppet::Network::FormatHandler.format(name)
             next unless format.suitable?
             return name
         end
 
         raise "No specified acceptable formats (%s) are functional on this machine" % header
     end
 
     def initialize_for_puppet(server)
         @server = server
     end
 
     # handle an HTTP request
     def process(request, response)
         indirection_request = uri2indirection(http_method(request), path(request), params(request))
 
         send("do_%s" % indirection_request.method, indirection_request, request, response)
     rescue Exception => e
         return do_exception(response, e)
     end
 
     # Set the response up, with the body and status.
     def set_response(response, body, status = 200)
         raise NotImplementedError
     end
 
     # Set the specified format as the content type of the response.
     def set_content_type(response, format)
         raise NotImplementedError
     end
 
     def do_exception(response, exception, status=400)
         if exception.is_a?(Exception)
             puts exception.backtrace if Puppet[:trace]
             Puppet.err(exception)
         end
         set_content_type(response, "text/plain")
         set_response(response, exception.to_s, status)
     end
 
     # Execute our find.
     def do_find(indirection_request, request, response)
         unless result = indirection_request.model.find(indirection_request.key, indirection_request.to_hash)
             return do_exception(response, "Could not find %s %s" % [indirection_request.indirection_name, indirection_request.key], 404)
         end
 
         # The encoding of the result must include the format to use,
         # and it needs to be used for both the rendering and as
         # the content type.
         format = format_to_use(request)
         set_content_type(response, format)
 
         set_response(response, result.render(format))
     end
 
     # Execute our search.
     def do_search(indirection_request, request, response)
         result = indirection_request.model.search(indirection_request.key, indirection_request.to_hash)
 
         if result.nil? or (result.is_a?(Array) and result.empty?)
             return do_exception(response, "Could not find instances in %s with '%s'" % [indirection_request.indirection_name, indirection_request.to_hash.inspect], 404)
         end
 
         format = format_to_use(request)
         set_content_type(response, format)
 
         set_response(response, indirection_request.model.render_multiple(format, result))
     end
 
     # Execute our destroy.
     def do_destroy(indirection_request, request, response)
         result = indirection_request.model.destroy(indirection_request.key, indirection_request.to_hash)
 
         set_content_type(response, "yaml")
 
         set_response(response, result.to_yaml)
     end
 
     # Execute our save.
     def do_save(indirection_request, request, response)
         data = body(request).to_s
         raise ArgumentError, "No data to save" if !data or data.empty?
 
         format = format_to_use(request)
 
         obj = indirection_request.model.convert_from(format_to_use(request), data)
         result = save_object(indirection_request, obj)
 
         set_content_type(response, "yaml")
 
         set_response(response, result.to_yaml)
     end
 
   private
 
     # LAK:NOTE This has to be here for testing; it's a stub-point so
     # we keep infinite recursion from happening.
     def save_object(ind_request, object)
         object.save(ind_request.to_hash)
     end
 
     def get?(request)
         http_method(request) == 'GET'
     end
 
     def put?(request)
         http_method(request) == 'PUT'
     end
 
     def delete?(request)
         http_method(request) == 'DELETE'
     end
 
     # methods to be overridden by the including web server class
 
     def http_method(request)
         raise NotImplementedError
     end
 
     def path(request)
         raise NotImplementedError
     end    
 
     def request_key(request)
         raise NotImplementedError
     end
 
     def body(request)
         raise NotImplementedError
     end
 
     def params(request)
         raise NotImplementedError
     end
 
     def decode_params(params)
         params.inject({}) do |result, ary|
             param, value = ary
+            param = param.to_sym
+
+            # These shouldn't be allowed to be set by clients
+            # in the query string, for security reasons.
+            next result if param == :node
+            next result if param == :ip
             value = URI.unescape(value)
             if value =~ /^---/
                 value = YAML.load(value)
             else
                 value = true if value == "true"
                 value = false if value == "false"
                 value = Integer(value) if value =~ /^\d+$/
                 value = value.to_f if value =~ /^\d+\.\d+$/
             end
-            result[param.to_sym] = value
+            result[param] = value
             result
         end
     end
 end
diff --git a/spec/unit/network/http/mongrel/rest.rb b/spec/unit/network/http/mongrel/rest.rb
index 84a7e7f64..1926a6e45 100755
--- a/spec/unit/network/http/mongrel/rest.rb
+++ b/spec/unit/network/http/mongrel/rest.rb
@@ -1,195 +1,205 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 
 require 'puppet/network/http'
 
 describe "Puppet::Network::HTTP::MongrelREST" do
     confine "Mongrel is not available" => Puppet.features.mongrel?
     before do
         require 'puppet/network/http/mongrel/rest'
     end
 
 
     it "should include the Puppet::Network::HTTP::Handler module" do
         Puppet::Network::HTTP::MongrelREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
     end
 
     describe "when initializing" do
         it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
             Puppet::Network::HTTP::MongrelREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
             Puppet::Network::HTTP::MongrelREST.new(:server => "my", :handler => "arguments")
         end
     end
 
     describe "when receiving a request" do
         before do
             @params = {}
             @request = stub('mongrel http request', :params => @params)
 
             @head = stub('response head')
             @body = stub('response body', :write => true)
             @response = stub('mongrel http response')
             @response.stubs(:start).yields(@head, @body)
             @model_class = stub('indirected model class')
             @mongrel = stub('mongrel http server', :register => true)
             Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
             @handler = Puppet::Network::HTTP::MongrelREST.new(:server => @mongrel, :handler => :foo)
         end
 
         describe "and using the HTTP Handler interface" do
             it "should return the HTTP_ACCEPT parameter as the accept header" do
                 @params.expects(:[]).with("HTTP_ACCEPT").returns "myaccept"
                 @handler.accept_header(@request).should == "myaccept"
             end
 
             it "should use the REQUEST_METHOD as the http method" do
                 @params.expects(:[]).with(Mongrel::Const::REQUEST_METHOD).returns "mymethod"
                 @handler.http_method(@request).should == "mymethod"
             end
 
             it "should return the request path as the path" do
                 @params.expects(:[]).with(Mongrel::Const::REQUEST_PATH).returns "/foo/bar"
                 @handler.path(@request).should == "/foo/bar"
             end
 
             it "should return the request body as the body" do
                 @request.expects(:body).returns "mybody"
                 @handler.body(@request).should == "mybody"
             end
 
             it "should set the response's content-type header when setting the content type" do
                 @header = mock 'header'
                 @response.expects(:header).returns @header
                 @header.expects(:[]=).with('Content-Type', "mytype")
 
                 @handler.set_content_type(@response, "mytype")
             end
 
             it "should set the status and write the body when setting the response for a successful request" do
                 head = mock 'head'
                 body = mock 'body'
                 @response.expects(:start).with(200).yields(head, body)
 
                 body.expects(:write).with("mybody")
 
                 @handler.set_response(@response, "mybody", 200)
             end
 
             it "should set the status and reason and write the body when setting the response for a successful request" do
                 head = mock 'head'
                 body = mock 'body'
                 @response.expects(:start).with(400, false, "mybody").yields(head, body)
 
                 body.expects(:write).with("mybody")
 
                 @handler.set_response(@response, "mybody", 400)
             end
         end
 
         describe "and determining the request parameters" do
             before do
                 @request.stubs(:params).returns({})
             end
 
             it "should include the HTTP request parameters, with the keys as symbols" do
                 @request.expects(:params).returns('QUERY_STRING' => 'foo=baz&bar=xyzzy')
                 result = @handler.params(@request)
                 result[:foo].should == "baz"
                 result[:bar].should == "xyzzy"
             end
 
             it "should URI-decode the HTTP parameters" do
                 encoding = URI.escape("foo bar")
                 @request.expects(:params).returns('QUERY_STRING' => "foo=#{encoding}")
                 result = @handler.params(@request)
                 result[:foo].should == "foo bar"
             end
 
             it "should convert the string 'true' to the boolean" do
                 @request.expects(:params).returns('QUERY_STRING' => 'foo=true')
                 result = @handler.params(@request)
                 result[:foo].should be_true
             end
 
             it "should convert the string 'false' to the boolean" do
                 @request.expects(:params).returns('QUERY_STRING' => 'foo=false')
                 result = @handler.params(@request)
                 result[:foo].should be_false
             end
 
             it "should convert integer arguments to Integers" do
                 @request.expects(:params).returns('QUERY_STRING' => 'foo=15')
                 result = @handler.params(@request)
                 result[:foo].should == 15
             end
 
             it "should convert floating point arguments to Floats" do
                 @request.expects(:params).returns('QUERY_STRING' => 'foo=1.5')
                 result = @handler.params(@request)
                 result[:foo].should == 1.5
             end
 
             it "should YAML-load and URI-decode values that are YAML-encoded" do
                 escaping = URI.escape(YAML.dump(%w{one two}))
                 @request.expects(:params).returns('QUERY_STRING' => "foo=#{escaping}")
                 result = @handler.params(@request)
                 result[:foo].should == %w{one two}
             end
 
+            it "should not allow the client to set the node via the query string" do
+                @request.stubs(:params).returns('QUERY_STRING' => "node=foo")
+                @handler.params(@request)[:node].should be_nil
+            end
+
+            it "should not allow the client to set the IP address via the query string" do
+                @request.stubs(:params).returns('QUERY_STRING' => "ip=foo")
+                @handler.params(@request)[:ip].should be_nil
+            end
+
             it "should pass the client's ip address to model find" do
                 @request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
                 @handler.params(@request)[:ip].should == "ipaddress"
             end
 
             it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
                 @handler.params(@request)
             end
 
             it "should retrieve the hostname by matching the certificate parameter" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
                 @handler.params(@request)[:node].should == "host.domain.com"
             end
 
             it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
                 @handler.params(@request)
             end
 
             it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
                 @handler.params(@request)[:authenticated].should be_true
             end
 
             it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
                 @handler.params(@request)[:authenticated].should be_false
             end
 
             it "should consider the host unauthenticated if no certificate information is present" do
                 Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
                 Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
                 @handler.params(@request)[:authenticated].should be_false
             end
 
             it "should not pass a node name to model method if no certificate information is present" do
                 Puppet.settings.stubs(:value).returns "eh"
                 Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
                 @request.stubs(:params).returns("myheader" => nil)
                 @handler.params(@request).should_not be_include(:node)
             end
         end
     end
 end
diff --git a/spec/unit/network/http/webrick/rest.rb b/spec/unit/network/http/webrick/rest.rb
index bb0918131..7600cff2c 100755
--- a/spec/unit/network/http/webrick/rest.rb
+++ b/spec/unit/network/http/webrick/rest.rb
@@ -1,137 +1,147 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../../../spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/webrick/rest'
 
 describe Puppet::Network::HTTP::WEBrickREST do
     it "should include the Puppet::Network::HTTP::Handler module" do
         Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
     end
 
     describe "when initializing" do
         it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
             Puppet::Network::HTTP::WEBrickREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
             Puppet::Network::HTTP::WEBrickREST.new("my", "arguments")
         end
     end
 
     describe "when receiving a request" do
         before do
             @request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
             @response    = stub('webrick http response', :status= => true, :body= => true)
             @model_class = stub('indirected model class')
             @webrick     = stub('webrick http server', :mount => true, :[] => {})
             Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
             @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick, :foo)
         end
 
         it "should delegate its :service method to its :process method" do
             @handler.expects(:process).with(@request, @response).returns "stuff"
             @handler.service(@request, @response).should == "stuff"
         end
 
         describe "when using the Handler interface" do
             it "should use the 'accept' request parameter as the Accept header" do
                 @request.expects(:[]).with("accept").returns "foobar"
                 @handler.accept_header(@request).should == "foobar"
             end
 
             it "should use the request method as the http method" do
                 @request.expects(:request_method).returns "FOO"
                 @handler.http_method(@request).should == "FOO"
             end
 
             it "should return the request path as the path" do
                 @request.expects(:path).returns "/foo/bar"
                 @handler.path(@request).should == "/foo/bar"
             end
 
             it "should return the request body as the body" do
                 @request.expects(:body).returns "my body"
                 @handler.body(@request).should == "my body"
             end
 
             it "should set the response's 'content-type' header when setting the content type" do
                 @response.expects(:[]=).with("content-type", "text/html")
                 @handler.set_content_type(@response, "text/html")
             end
 
             it "should set the status and body on the response when setting the response for a successful query" do
                 @response.expects(:status=).with 200
                 @response.expects(:body=).with "mybody"
 
                 @handler.set_response(@response, "mybody", 200)
             end
 
             it "should set the status and message on the response when setting the response for a failed query" do
                 @response.expects(:status=).with 400
                 @response.expects(:reason_phrase=).with "mybody"
 
                 @handler.set_response(@response, "mybody", 400)
             end
         end
 
         describe "and determining the request parameters" do
             it "should include the HTTP request parameters, with the keys as symbols" do
                 @request.stubs(:query).returns("foo" => "baz", "bar" => "xyzzy")
                 result = @handler.params(@request)
                 result[:foo].should == "baz"
                 result[:bar].should == "xyzzy"
             end
 
             it "should URI-decode the HTTP parameters" do
                 encoding = URI.escape("foo bar")
                 @request.expects(:query).returns('foo' => encoding)
                 result = @handler.params(@request)
                 result[:foo].should == "foo bar"
             end
 
             it "should convert the string 'true' to the boolean" do
                 @request.expects(:query).returns('foo' => "true")
                 result = @handler.params(@request)
                 result[:foo].should be_true
             end
 
             it "should convert the string 'false' to the boolean" do
                 @request.expects(:query).returns('foo' => "false")
                 result = @handler.params(@request)
                 result[:foo].should be_false
             end
 
             it "should YAML-load and URI-decode values that are YAML-encoded" do
                 escaping = URI.escape(YAML.dump(%w{one two}))
                 @request.expects(:query).returns('foo' => escaping)
                 result = @handler.params(@request)
                 result[:foo].should == %w{one two}
             end
 
+            it "should not allow clients to set the node via the request parameters" do
+                @request.stubs(:query).returns("node" => "foo")
+                @handler.params(@request)[:node].should be_nil
+            end
+
+            it "should not allow clients to set the IP via the request parameters" do
+                @request.stubs(:query).returns("ip" => "foo")
+                @handler.params(@request)[:ip].should_not == "foo"
+            end
+
             it "should pass the client's ip address to model find" do
                 @request.stubs(:peeraddr).returns(%w{noidea dunno hostname ipaddress})
                 @handler.params(@request)[:ip].should == "ipaddress"
             end
 
             it "should set 'authenticated' to true if a certificate is present" do
                 cert = stub 'cert', :subject => [%w{CN host.domain.com}]
                 @request.stubs(:client_cert).returns cert
                 @handler.params(@request)[:authenticated].should be_true
             end
 
             it "should set 'authenticated' to false if no certificate is present" do
                 @request.stubs(:client_cert).returns nil
                 @handler.params(@request)[:authenticated].should be_false
             end
 
             it "should pass the client's certificate name to model method if a certificate is present" do
                 cert = stub 'cert', :subject => [%w{CN host.domain.com}]
                 @request.stubs(:client_cert).returns cert
                 @handler.params(@request)[:node].should == "host.domain.com"
             end
 
             it "should not pass a node name to model method if no certificate is present" do
                 @request.stubs(:client_cert).returns nil
                 @handler.params(@request).should_not be_include(:node)
             end
         end
     end
 end