diff --git a/bgpwtf/cccampix/irr/provider/BUILD.bazel b/bgpwtf/cccampix/irr/provider/BUILD.bazel
new file mode 100644
index 0000000..f39744e
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/BUILD.bazel
@@ -0,0 +1,30 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "arin.go",
+        "iana.go",
+        "provider.go",
+        "ripe.go",
+        "rpsl.go",
+    ],
+    importpath = "code.hackerspace.pl/hscloud/bgpwtf/cccampix/irr/provider",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//bgpwtf/cccampix/irr/whois:go_default_library",
+        "//bgpwtf/cccampix/proto:go_default_library",
+        "@com_github_golang_collections_go_datastructures//augmentedtree:go_default_library",
+        "@com_github_golang_glog//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["rpsl_test.go"],
+    embed = [":go_default_library"],
+    deps = [
+        "//bgpwtf/cccampix/proto:go_default_library",
+        "@com_github_go_test_deep//:go_default_library",
+    ],
+)
diff --git a/bgpwtf/cccampix/irr/provider/arin.go b/bgpwtf/cccampix/irr/provider/arin.go
new file mode 100644
index 0000000..1781198
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/arin.go
@@ -0,0 +1,78 @@
+package provider
+
+// Support for the ARIN IRR.
+// ARIN is special. We have to query them via whois. It's also not the same
+// whois as you usually see. And also not many autnums (even big players like
+// AS15169 and AS112) have IRR entries at all.
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"code.hackerspace.pl/hscloud/bgpwtf/cccampix/irr/whois"
+	pb "code.hackerspace.pl/hscloud/bgpwtf/cccampix/proto"
+)
+
+const ARINWhois = "rr.arin.net:43"
+
+type arin struct {
+}
+
+func NewARIN() Provider {
+	return &arin{}
+}
+
+func (r *arin) Query(ctx context.Context, asn uint64) (*pb.IRRQueryResponse, error) {
+	data, err := whois.Query(ctx, ARINWhois, fmt.Sprintf("AS%d", asn))
+	if err != nil {
+		return nil, fmt.Errorf("could not contact ARIN IRR: %v", err)
+	}
+
+	lines := strings.Split(data, "\n")
+
+	// Convert possibly 'continued' RPSL entries into single-line entries.
+	// eg.
+	//   import:         from AS6083
+	//                   action pref=10;
+	//                   accept ANY
+	// into
+	//  'import', 'from AS6083, action pref=10; accept ANY'
+
+	attrs := []rpslRawAttribute{}
+	for _, line := range lines {
+		if strings.HasPrefix(strings.TrimSpace(line), "%") {
+			// Comment
+			continue
+		}
+		if strings.TrimSpace(line) == "" {
+			// Empty line
+			continue
+		}
+
+		if strings.HasPrefix(line, " ") {
+			// Continuation
+			if len(attrs) < 1 {
+				return nil, fmt.Errorf("unparseable IRR, continuation with no previous atribute name: %q", line)
+			}
+
+			attrs[len(attrs)-1].value += " " + strings.TrimSpace(line)
+		} else {
+			parts := strings.SplitN(line, ":", 2)
+			if len(parts) != 2 {
+				return nil, fmt.Errorf("unparseable IRR, line with no attribute key: %q", line)
+			}
+			name := strings.TrimSpace(parts[0])
+			value := strings.TrimSpace(parts[1])
+			attrs = append(attrs, rpslRawAttribute{
+				name:  name,
+				value: value,
+			})
+		}
+	}
+
+	return &pb.IRRQueryResponse{
+		Source:     pb.IRRQueryResponse_SOURCE_ARIN,
+		Attributes: parseAttributes(attrs),
+	}, nil
+}
diff --git a/bgpwtf/cccampix/irr/provider/iana.go b/bgpwtf/cccampix/irr/provider/iana.go
new file mode 100644
index 0000000..8f085d2
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/iana.go
@@ -0,0 +1,163 @@
+package provider
+
+// IANA is not a full provider - we use it to determine the relevant IRR for a given aut-num.
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/golang-collections/go-datastructures/augmentedtree"
+	"github.com/golang/glog"
+
+	"code.hackerspace.pl/hscloud/bgpwtf/cccampix/irr/whois"
+)
+
+// Possible IRRs that AS blocks can be delegated to.
+type IRR int
+
+const (
+	IRR_UNKNOWN IRR = iota
+	IRR_ARIN
+	IRR_RIPE
+)
+
+func (i IRR) String() string {
+	return []string{
+		"UNKNOWN",
+		"ARIN",
+		"RIPE",
+	}[i]
+}
+
+// IANA access service.
+type IANA struct {
+	// Interval tree of AS block delegation to IRRs. We use this to not
+	// keep hitting the IANA whois unnecessariy.
+	cache augmentedtree.Tree
+	// The tree library needs intervals to have a unique ID. We use a counter
+	// for this effect.
+	id uint64
+}
+
+func NewIANA() *IANA {
+	return &IANA{
+		cache: augmentedtree.New(1),
+	}
+}
+
+func (i *IANA) nextID() uint64 {
+	res := i.id
+	i.id += 1
+	return res
+}
+
+// delegation implements the Interval interface for the interval tree.
+type delegation struct {
+	to   IRR
+	id   uint64
+	low  int64
+	high int64
+}
+
+func (d *delegation) LowAtDimension(n uint64) int64 {
+	if n != 1 {
+		panic(fmt.Sprintf("dimension too high (%d)", n))
+	}
+	return d.low
+}
+
+func (d *delegation) HighAtDimension(n uint64) int64 {
+	if n != 1 {
+		panic(fmt.Sprintf("dimension too high (%d)", n))
+	}
+	return d.high
+}
+
+func (d *delegation) OverlapsAtDimension(i augmentedtree.Interval, n uint64) bool {
+	if n != 1 {
+		return false
+	}
+
+	if i.LowAtDimension(1) <= d.HighAtDimension(1) && i.HighAtDimension(1) >= d.LowAtDimension(1) {
+		return true
+	}
+
+	return false
+}
+
+func (d *delegation) ID() uint64 {
+	return d.id
+}
+
+// Who returns the responsible IRR (or UNKNOWN) for a given AS.
+func (i *IANA) Who(ctx context.Context, asn uint64) (IRR, error) {
+	q := &delegation{
+		id:   i.nextID(),
+		low:  int64(asn),
+		high: int64(asn),
+	}
+
+	res := i.cache.Query(q)
+	if len(res) > 0 {
+		return res[0].(*delegation).to, nil
+	}
+
+	// No cache entry, query whois.
+	glog.Infof("Cache miss for AS%d", asn)
+	data, err := whois.Query(ctx, "whois.iana.org:43", fmt.Sprintf("AS%d", asn))
+	if err != nil {
+		return IRR_UNKNOWN, err
+	}
+
+	// We not only find the responsible IRR, but also the delegation bounds
+	// to feed the interval tree.
+	lines := strings.Split(data, "\n")
+	var lower int64
+	var upper int64
+	var irr IRR
+	for _, line := range lines {
+		parts := strings.Fields(line)
+		if len(parts) == 2 && parts[0] == "as-block:" {
+			bounds := strings.Split(parts[1], "-")
+			if len(bounds) != 2 {
+				return IRR_UNKNOWN, fmt.Errorf("unparseable as-block: %v", parts[1])
+			}
+			lower, err = strconv.ParseInt(bounds[0], 10, 64)
+			if err != nil {
+				return IRR_UNKNOWN, fmt.Errorf("unparseable as-block: %v", parts[1])
+			}
+			upper, err = strconv.ParseInt(bounds[1], 10, 64)
+			if err != nil {
+				return IRR_UNKNOWN, fmt.Errorf("unparseable as-block: %v", parts[1])
+			}
+		}
+		if len(parts) > 2 && parts[0] == "organisation:" {
+			switch {
+			case strings.Contains(line, "RIPE NCC"):
+				irr = IRR_RIPE
+			case strings.Contains(line, "ARIN"):
+				irr = IRR_ARIN
+			}
+		}
+	}
+
+	if lower == 0 || upper == 0 {
+		return IRR_UNKNOWN, nil
+	}
+
+	glog.Infof("Saving %d-%d AS blocks delegation (%s) to cache", lower, upper, irr.String())
+
+	// Insert into tree.
+	q = &delegation{
+		id:   i.nextID(),
+		to:   irr,
+		low:  lower,
+		high: upper + 1,
+	}
+
+	i.cache.Add(q)
+
+	return irr, nil
+}
diff --git a/bgpwtf/cccampix/irr/provider/provider.go b/bgpwtf/cccampix/irr/provider/provider.go
new file mode 100644
index 0000000..4e2921b
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/provider.go
@@ -0,0 +1,13 @@
+package provider
+
+import (
+	"context"
+
+	pb "code.hackerspace.pl/hscloud/bgpwtf/cccampix/proto"
+)
+
+// Provider is the interface exposed to the service by IRR proxies.
+type Provider interface {
+	// Return a proto response for a given AS.
+	Query(ctx context.Context, as uint64) (*pb.IRRQueryResponse, error)
+}
diff --git a/bgpwtf/cccampix/irr/provider/ripe.go b/bgpwtf/cccampix/irr/provider/ripe.go
new file mode 100644
index 0000000..5b09b9f
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/ripe.go
@@ -0,0 +1,81 @@
+package provider
+
+// Support for the RIPE IRR.
+// We use the RIPE REST DB API.
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+
+	pb "code.hackerspace.pl/hscloud/bgpwtf/cccampix/proto"
+)
+
+type ripeResponse struct {
+	Objects struct {
+		Object []ripeObject `json:"object"`
+	} `json:"objects"`
+}
+
+type ripeObject struct {
+	Type       string `json:"type"`
+	Attributes struct {
+		Attribute []ripeAttribute `json:"attribute"`
+	} `json:"attributes"`
+}
+
+type ripeAttribute struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
+type ripe struct {
+}
+
+func NewRIPE() Provider {
+	return &ripe{}
+}
+
+func (r *ripe) Query(ctx context.Context, as uint64) (*pb.IRRQueryResponse, error) {
+	req, err := http.NewRequest("GET", fmt.Sprintf("http://rest.db.ripe.net/ripe/aut-num/AS%d.json", as), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req = req.WithContext(ctx)
+	client := http.DefaultClient
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("could not run GET to RIPE: %v", err)
+	}
+	defer res.Body.Close()
+	bytes, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return nil, fmt.Errorf("could not read response from RIPE: %v", err)
+	}
+
+	data := ripeResponse{}
+	err = json.Unmarshal(bytes, &data)
+	if err != nil {
+		return nil, fmt.Errorf("could not decode response from RIPE: %v", err)
+	}
+
+	if len(data.Objects.Object) != 1 {
+		return nil, fmt.Errorf("could not retriev aut-num from RIPE")
+	}
+
+	attributes := make([]rpslRawAttribute, len(data.Objects.Object[0].Attributes.Attribute))
+
+	for i, attr := range data.Objects.Object[0].Attributes.Attribute {
+		attributes[i].name = attr.Name
+		attributes[i].value = attr.Value
+	}
+
+	return &pb.IRRQueryResponse{
+		Source:     pb.IRRQueryResponse_SOURCE_RIPE,
+		Attributes: parseAttributes(attributes),
+	}, nil
+}
diff --git a/bgpwtf/cccampix/irr/provider/rpsl.go b/bgpwtf/cccampix/irr/provider/rpsl.go
new file mode 100644
index 0000000..68a1f51
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/rpsl.go
@@ -0,0 +1,146 @@
+package provider
+
+import (
+	"strings"
+
+	pb "code.hackerspace.pl/hscloud/bgpwtf/cccampix/proto"
+)
+
+// A raw, unparsed RPSL name/value pair.
+type rpslRawAttribute struct {
+	name  string
+	value string
+}
+
+// parseAttributes converts raw RPSL attributes into parsed, structured protos.
+func parseAttributes(attrs []rpslRawAttribute) []*pb.IRRAttribute {
+	res := []*pb.IRRAttribute{}
+
+	for _, attr := range attrs {
+		switch attr.name {
+		case "remarks":
+			res = append(res, &pb.IRRAttribute{
+				Value: &pb.IRRAttribute_Remarks{attr.value},
+			})
+		case "import":
+			ie := parseImportExport(attr.value)
+			if ie != nil {
+				res = append(res, &pb.IRRAttribute{
+					Value: &pb.IRRAttribute_Import{ie},
+				})
+			}
+		case "export":
+			ie := parseImportExport(attr.value)
+			if ie != nil {
+				res = append(res, &pb.IRRAttribute{
+					Value: &pb.IRRAttribute_Export{ie},
+				})
+			}
+		}
+	}
+
+	return res
+}
+
+// parseImportExport tries to parse the RPSL subset for import/export
+// attributes.
+// It's a hand-written single-pass parser which makes it not very good.
+// See rpsl_test.go for examples.
+func parseImportExport(expression string) *pb.IRRAttribute_ImportExport {
+	popToken := func(s string) (string, string) {
+		s = strings.TrimSpace(s)
+		fields := strings.Fields(s)
+		if len(fields) < 2 {
+			return "", s
+		}
+		return fields[0], strings.TrimSpace(s[len(fields[0]):])
+	}
+
+	res := &pb.IRRAttribute_ImportExport{}
+
+	expr := expression
+	var t string
+	t, expr = popToken(expr)
+
+	for {
+		switch t {
+		case "":
+			break
+		case "protocol":
+			t, expr = popToken(expr)
+			res.ProtocolFrom = t
+			t, expr = popToken(expr)
+			continue
+		case "into":
+			t, expr = popToken(expr)
+			res.ProtocolInto = t
+			t, expr = popToken(expr)
+			continue
+		case "from":
+			fallthrough
+		case "to":
+			t, expr = popToken(expr)
+			peering := t
+			actions := []string{}
+			router_us := ""
+			router_them := ""
+
+			t2, expr2 := popToken(expr)
+			for {
+				switch t2 {
+				case "at":
+					t2, expr2 = popToken(expr2)
+					router_us = t2
+					t2, expr2 = popToken(expr2)
+					continue
+				case "action":
+					parts := strings.SplitN(expr2, ";", 2)
+					if len(parts) != 2 {
+						// malformed action, no ';' found - bail
+						return nil
+					}
+					actions = append(actions, parts[0])
+					expr2 = strings.TrimSpace(parts[1])
+					t2, expr2 = popToken(expr2)
+					continue
+				case "":
+					fallthrough
+				case "accept":
+					fallthrough
+				case "announce":
+					t = t2
+					expr = expr2
+					break
+				default:
+					if router_them == "" {
+						router_them = t2
+						t2, expr2 = popToken(expr2)
+						continue
+					}
+					t = t2
+					expr = expr2
+					break
+				}
+				break
+			}
+			res.Expressions = append(res.Expressions, &pb.IRRAttribute_ImportExport_Expression{
+				Peering:    peering,
+				RouterUs:   router_us,
+				RouterThem: router_them,
+				Actions:    actions,
+			})
+			continue
+		case "accept":
+			fallthrough
+		case "announce":
+			res.Filter = expr
+			t = ""
+			continue
+		default:
+			return nil
+		}
+		break
+	}
+
+	return res
+}
diff --git a/bgpwtf/cccampix/irr/provider/rpsl_test.go b/bgpwtf/cccampix/irr/provider/rpsl_test.go
new file mode 100644
index 0000000..2c0fe57
--- /dev/null
+++ b/bgpwtf/cccampix/irr/provider/rpsl_test.go
@@ -0,0 +1,64 @@
+package provider
+
+import (
+	"testing"
+
+	pb "code.hackerspace.pl/hscloud/bgpwtf/cccampix/proto"
+	"github.com/go-test/deep"
+)
+
+func TestParseImportExport(t *testing.T) {
+	tests := []struct {
+		ut   string
+		want *pb.IRRAttribute_ImportExport
+	}{
+		{
+			ut: `
+				from AS10674 209.251.128.177 at 216.155.103.20 action pref = 1;
+				accept ANY AND NOT AS-ACCELERATION-CUST
+			`,
+			want: &pb.IRRAttribute_ImportExport{
+				Expressions: []*pb.IRRAttribute_ImportExport_Expression{
+					{
+						Peering:    "AS10674",
+						RouterUs:   "216.155.103.20",
+						RouterThem: "209.251.128.177",
+						Actions:    []string{"pref = 1"},
+					},
+				},
+				Filter: "ANY AND NOT AS-ACCELERATION-CUST",
+			},
+		},
+		{
+			ut: `
+				to AS201054 94.246.185.174 at 94.246.185.175 announce AS-BGPWTF
+			`,
+			want: &pb.IRRAttribute_ImportExport{
+				Expressions: []*pb.IRRAttribute_ImportExport_Expression{
+					{
+						Peering:    "AS201054",
+						RouterUs:   "94.246.185.175",
+						RouterThem: "94.246.185.174",
+						Actions:    []string{},
+					},
+				},
+				Filter: "AS-BGPWTF",
+			},
+		},
+		{
+			// Invalid - unterminated action.
+			ut: `
+				to AS201054 94.246.185.174 at 94.246.185.175 action foo = bar
+				accept ANY AND NOT AS-ACCELERATION-CUST
+			`,
+			want: nil,
+		},
+	}
+
+	for _, test := range tests {
+		res := parseImportExport(test.ut)
+		if diff := deep.Equal(test.want, res); diff != nil {
+			t.Error(diff)
+		}
+	}
+}