├── .gitignore
├── HTTPTransform.cpp
├── HTTPTransform.hpp
├── LICENSE
├── Makefile
├── Proxy.cpp
├── Proxy.hpp
├── Server.cpp
├── Server.hpp
├── main.cpp
└── net
    ├── HTTP.cpp
    ├── HTTP.hpp
    ├── TCPSocket.cpp
    └── TCPSocket.hpp


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Object files
 2 | *.o
 3 | *.ko
 4 | *.obj
 5 | *.elf
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Libraries
12 | *.lib
13 | *.a
14 | *.la
15 | *.lo
16 | 
17 | # Shared objects (inc. Windows DLLs)
18 | *.dll
19 | *.so
20 | *.so.*
21 | *.dylib
22 | 
23 | # Executables
24 | *.exe
25 | *.out
26 | *.app
27 | *.i*86
28 | *.x86_64
29 | *.hex
30 | 


--------------------------------------------------------------------------------
/HTTPTransform.cpp:
--------------------------------------------------------------------------------
 1 | #include "HTTPTransform.hpp"
 2 | 
 3 | #include <vector>
 4 | 
 5 | void HTTPTransform::addRequestTransform(std::function <void (net::HTTP &request)> transform) {
 6 |     std::lock_guard <std::shared_timed_mutex> lock(requestMutex);
 7 | 
 8 |     requestTransformations.push_back(transform);
 9 | }
10 | 
11 | void HTTPTransform::addResponseTransform(std::function <void (net::HTTP &response)> transform) {
12 |     std::lock_guard <std::shared_timed_mutex> lock(responseMutex);
13 | 
14 |     responseTransformations.push_back(transform);
15 | }
16 | 
17 | void HTTPTransform::clearRequestTransform() {
18 |     std::lock_guard <std::shared_timed_mutex> lock(requestMutex);
19 | 
20 |     requestTransformations.clear();
21 | }
22 | 
23 | void HTTPTransform::clearResponseTransform() {
24 |     std::lock_guard <std::shared_timed_mutex> lock(responseMutex);
25 | 
26 |     responseTransformations.clear();
27 | }
28 | 
29 | void HTTPTransform::transformRequest(net::HTTP &request) {
30 |     std::shared_lock <std::shared_timed_mutex> lock(requestMutex);
31 | 
32 |     for (auto &fun : requestTransformations)
33 |         fun(request);
34 | }
35 | 
36 | void HTTPTransform::transformResponse(net::HTTP &response) {
37 |     std::shared_lock <std::shared_timed_mutex> lock(responseMutex);
38 | 
39 |     for (auto &fun : responseTransformations)
40 |         fun(response);
41 | }
42 | 


--------------------------------------------------------------------------------
/HTTPTransform.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <vector>
 4 | #include <shared_mutex>
 5 | 
 6 | #include "net/HTTP.hpp"
 7 | 
 8 | class HTTPTransform
 9 | {
10 |     public:
11 |         void addRequestTransform(std::function <void (net::HTTP &request)> transform);
12 |         void addResponseTransform(std::function <void (net::HTTP &response)> transform);
13 |         void clearRequestTransform();
14 |         void clearResponseTransform();
15 | 
16 |         void transformRequest(net::HTTP &request);
17 |         void transformResponse(net::HTTP &response);
18 |     private:
19 |         std::vector <std::function <void (net::HTTP &request)>> requestTransformations;
20 |         std::vector <std::function <void (net::HTTP &response)>> responseTransformations;
21 | 
22 |         std::shared_timed_mutex requestMutex;
23 |         std::shared_timed_mutex responseMutex;
24 | };
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | GNU GENERAL PUBLIC LICENSE
  2 |                        Version 2, June 1991
  3 | 
  4 |  Copyright (C) 1989, 1991 Free Software Foundation, Inc., <http://fsf.org/>
  5 |  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  6 |  Everyone is permitted to copy and distribute verbatim copies
  7 |  of this license document, but changing it is not allowed.
  8 | 
  9 |                             Preamble
 10 | 
 11 |   The licenses for most software are designed to take away your
 12 | freedom to share and change it.  By contrast, the GNU General Public
 13 | License is intended to guarantee your freedom to share and change free
 14 | software--to make sure the software is free for all its users.  This
 15 | General Public License applies to most of the Free Software
 16 | Foundation's software and to any other program whose authors commit to
 17 | using it.  (Some other Free Software Foundation software is covered by
 18 | the GNU Lesser General Public License instead.)  You can apply it to
 19 | your programs, too.
 20 | 
 21 |   When we speak of free software, we are referring to freedom, not
 22 | price.  Our General Public Licenses are designed to make sure that you
 23 | have the freedom to distribute copies of free software (and charge for
 24 | this service if you wish), that you receive source code or can get it
 25 | if you want it, that you can change the software or use pieces of it
 26 | in new free programs; and that you know you can do these things.
 27 | 
 28 |   To protect your rights, we need to make restrictions that forbid
 29 | anyone to deny you these rights or to ask you to surrender the rights.
 30 | These restrictions translate to certain responsibilities for you if you
 31 | distribute copies of the software, or if you modify it.
 32 | 
 33 |   For example, if you distribute copies of such a program, whether
 34 | gratis or for a fee, you must give the recipients all the rights that
 35 | you have.  You must make sure that they, too, receive or can get the
 36 | source code.  And you must show them these terms so they know their
 37 | rights.
 38 | 
 39 |   We protect your rights with two steps: (1) copyright the software, and
 40 | (2) offer you this license which gives you legal permission to copy,
 41 | distribute and/or modify the software.
 42 | 
 43 |   Also, for each author's protection and ours, we want to make certain
 44 | that everyone understands that there is no warranty for this free
 45 | software.  If the software is modified by someone else and passed on, we
 46 | want its recipients to know that what they have is not the original, so
 47 | that any problems introduced by others will not reflect on the original
 48 | authors' reputations.
 49 | 
 50 |   Finally, any free program is threatened constantly by software
 51 | patents.  We wish to avoid the danger that redistributors of a free
 52 | program will individually obtain patent licenses, in effect making the
 53 | program proprietary.  To prevent this, we have made it clear that any
 54 | patent must be licensed for everyone's free use or not licensed at all.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                     GNU GENERAL PUBLIC LICENSE
 60 |    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 61 | 
 62 |   0. This License applies to any program or other work which contains
 63 | a notice placed by the copyright holder saying it may be distributed
 64 | under the terms of this General Public License.  The "Program", below,
 65 | refers to any such program or work, and a "work based on the Program"
 66 | means either the Program or any derivative work under copyright law:
 67 | that is to say, a work containing the Program or a portion of it,
 68 | either verbatim or with modifications and/or translated into another
 69 | language.  (Hereinafter, translation is included without limitation in
 70 | the term "modification".)  Each licensee is addressed as "you".
 71 | 
 72 | Activities other than copying, distribution and modification are not
 73 | covered by this License; they are outside its scope.  The act of
 74 | running the Program is not restricted, and the output from the Program
 75 | is covered only if its contents constitute a work based on the
 76 | Program (independent of having been made by running the Program).
 77 | Whether that is true depends on what the Program does.
 78 | 
 79 |   1. You may copy and distribute verbatim copies of the Program's
 80 | source code as you receive it, in any medium, provided that you
 81 | conspicuously and appropriately publish on each copy an appropriate
 82 | copyright notice and disclaimer of warranty; keep intact all the
 83 | notices that refer to this License and to the absence of any warranty;
 84 | and give any other recipients of the Program a copy of this License
 85 | along with the Program.
 86 | 
 87 | You may charge a fee for the physical act of transferring a copy, and
 88 | you may at your option offer warranty protection in exchange for a fee.
 89 | 
 90 |   2. You may modify your copy or copies of the Program or any portion
 91 | of it, thus forming a work based on the Program, and copy and
 92 | distribute such modifications or work under the terms of Section 1
 93 | above, provided that you also meet all of these conditions:
 94 | 
 95 |     a) You must cause the modified files to carry prominent notices
 96 |     stating that you changed the files and the date of any change.
 97 | 
 98 |     b) You must cause any work that you distribute or publish, that in
 99 |     whole or in part contains or is derived from the Program or any
100 |     part thereof, to be licensed as a whole at no charge to all third
101 |     parties under the terms of this License.
102 | 
103 |     c) If the modified program normally reads commands interactively
104 |     when run, you must cause it, when started running for such
105 |     interactive use in the most ordinary way, to print or display an
106 |     announcement including an appropriate copyright notice and a
107 |     notice that there is no warranty (or else, saying that you provide
108 |     a warranty) and that users may redistribute the program under
109 |     these conditions, and telling the user how to view a copy of this
110 |     License.  (Exception: if the Program itself is interactive but
111 |     does not normally print such an announcement, your work based on
112 |     the Program is not required to print an announcement.)
113 | 
114 | These requirements apply to the modified work as a whole.  If
115 | identifiable sections of that work are not derived from the Program,
116 | and can be reasonably considered independent and separate works in
117 | themselves, then this License, and its terms, do not apply to those
118 | sections when you distribute them as separate works.  But when you
119 | distribute the same sections as part of a whole which is a work based
120 | on the Program, the distribution of the whole must be on the terms of
121 | this License, whose permissions for other licensees extend to the
122 | entire whole, and thus to each and every part regardless of who wrote it.
123 | 
124 | Thus, it is not the intent of this section to claim rights or contest
125 | your rights to work written entirely by you; rather, the intent is to
126 | exercise the right to control the distribution of derivative or
127 | collective works based on the Program.
128 | 
129 | In addition, mere aggregation of another work not based on the Program
130 | with the Program (or with a work based on the Program) on a volume of
131 | a storage or distribution medium does not bring the other work under
132 | the scope of this License.
133 | 
134 |   3. You may copy and distribute the Program (or a work based on it,
135 | under Section 2) in object code or executable form under the terms of
136 | Sections 1 and 2 above provided that you also do one of the following:
137 | 
138 |     a) Accompany it with the complete corresponding machine-readable
139 |     source code, which must be distributed under the terms of Sections
140 |     1 and 2 above on a medium customarily used for software interchange; or,
141 | 
142 |     b) Accompany it with a written offer, valid for at least three
143 |     years, to give any third party, for a charge no more than your
144 |     cost of physically performing source distribution, a complete
145 |     machine-readable copy of the corresponding source code, to be
146 |     distributed under the terms of Sections 1 and 2 above on a medium
147 |     customarily used for software interchange; or,
148 | 
149 |     c) Accompany it with the information you received as to the offer
150 |     to distribute corresponding source code.  (This alternative is
151 |     allowed only for noncommercial distribution and only if you
152 |     received the program in object code or executable form with such
153 |     an offer, in accord with Subsection b above.)
154 | 
155 | The source code for a work means the preferred form of the work for
156 | making modifications to it.  For an executable work, complete source
157 | code means all the source code for all modules it contains, plus any
158 | associated interface definition files, plus the scripts used to
159 | control compilation and installation of the executable.  However, as a
160 | special exception, the source code distributed need not include
161 | anything that is normally distributed (in either source or binary
162 | form) with the major components (compiler, kernel, and so on) of the
163 | operating system on which the executable runs, unless that component
164 | itself accompanies the executable.
165 | 
166 | If distribution of executable or object code is made by offering
167 | access to copy from a designated place, then offering equivalent
168 | access to copy the source code from the same place counts as
169 | distribution of the source code, even though third parties are not
170 | compelled to copy the source along with the object code.
171 | 
172 |   4. You may not copy, modify, sublicense, or distribute the Program
173 | except as expressly provided under this License.  Any attempt
174 | otherwise to copy, modify, sublicense or distribute the Program is
175 | void, and will automatically terminate your rights under this License.
176 | However, parties who have received copies, or rights, from you under
177 | this License will not have their licenses terminated so long as such
178 | parties remain in full compliance.
179 | 
180 |   5. You are not required to accept this License, since you have not
181 | signed it.  However, nothing else grants you permission to modify or
182 | distribute the Program or its derivative works.  These actions are
183 | prohibited by law if you do not accept this License.  Therefore, by
184 | modifying or distributing the Program (or any work based on the
185 | Program), you indicate your acceptance of this License to do so, and
186 | all its terms and conditions for copying, distributing or modifying
187 | the Program or works based on it.
188 | 
189 |   6. Each time you redistribute the Program (or any work based on the
190 | Program), the recipient automatically receives a license from the
191 | original licensor to copy, distribute or modify the Program subject to
192 | these terms and conditions.  You may not impose any further
193 | restrictions on the recipients' exercise of the rights granted herein.
194 | You are not responsible for enforcing compliance by third parties to
195 | this License.
196 | 
197 |   7. If, as a consequence of a court judgment or allegation of patent
198 | infringement or for any other reason (not limited to patent issues),
199 | conditions are imposed on you (whether by court order, agreement or
200 | otherwise) that contradict the conditions of this License, they do not
201 | excuse you from the conditions of this License.  If you cannot
202 | distribute so as to satisfy simultaneously your obligations under this
203 | License and any other pertinent obligations, then as a consequence you
204 | may not distribute the Program at all.  For example, if a patent
205 | license would not permit royalty-free redistribution of the Program by
206 | all those who receive copies directly or indirectly through you, then
207 | the only way you could satisfy both it and this License would be to
208 | refrain entirely from distribution of the Program.
209 | 
210 | If any portion of this section is held invalid or unenforceable under
211 | any particular circumstance, the balance of the section is intended to
212 | apply and the section as a whole is intended to apply in other
213 | circumstances.
214 | 
215 | It is not the purpose of this section to induce you to infringe any
216 | patents or other property right claims or to contest validity of any
217 | such claims; this section has the sole purpose of protecting the
218 | integrity of the free software distribution system, which is
219 | implemented by public license practices.  Many people have made
220 | generous contributions to the wide range of software distributed
221 | through that system in reliance on consistent application of that
222 | system; it is up to the author/donor to decide if he or she is willing
223 | to distribute software through any other system and a licensee cannot
224 | impose that choice.
225 | 
226 | This section is intended to make thoroughly clear what is believed to
227 | be a consequence of the rest of this License.
228 | 
229 |   8. If the distribution and/or use of the Program is restricted in
230 | certain countries either by patents or by copyrighted interfaces, the
231 | original copyright holder who places the Program under this License
232 | may add an explicit geographical distribution limitation excluding
233 | those countries, so that distribution is permitted only in or among
234 | countries not thus excluded.  In such case, this License incorporates
235 | the limitation as if written in the body of this License.
236 | 
237 |   9. The Free Software Foundation may publish revised and/or new versions
238 | of the General Public License from time to time.  Such new versions will
239 | be similar in spirit to the present version, but may differ in detail to
240 | address new problems or concerns.
241 | 
242 | Each version is given a distinguishing version number.  If the Program
243 | specifies a version number of this License which applies to it and "any
244 | later version", you have the option of following the terms and conditions
245 | either of that version or of any later version published by the Free
246 | Software Foundation.  If the Program does not specify a version number of
247 | this License, you may choose any version ever published by the Free Software
248 | Foundation.
249 | 
250 |   10. If you wish to incorporate parts of the Program into other free
251 | programs whose distribution conditions are different, write to the author
252 | to ask for permission.  For software which is copyrighted by the Free
253 | Software Foundation, write to the Free Software Foundation; we sometimes
254 | make exceptions for this.  Our decision will be guided by the two goals
255 | of preserving the free status of all derivatives of our free software and
256 | of promoting the sharing and reuse of software generally.
257 | 
258 |                             NO WARRANTY
259 | 
260 |   11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
268 | REPAIR OR CORRECTION.
269 | 
270 |   12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
278 | POSSIBILITY OF SUCH DAMAGES.
279 | 
280 |                      END OF TERMS AND CONDITIONS
281 | 
282 |             How to Apply These Terms to Your New Programs
283 | 
284 |   If you develop a new program, and you want it to be of the greatest
285 | possible use to the public, the best way to achieve this is to make it
286 | free software which everyone can redistribute and change under these terms.
287 | 
288 |   To do so, attach the following notices to the program.  It is safest
289 | to attach them to the start of each source file to most effectively
290 | convey the exclusion of warranty; and each file should have at least
291 | the "copyright" line and a pointer to where the full notice is found.
292 | 
293 |     {description}
294 |     Copyright (C) {year}  {fullname}
295 | 
296 |     This program is free software; you can redistribute it and/or modify
297 |     it under the terms of the GNU General Public License as published by
298 |     the Free Software Foundation; either version 2 of the License, or
299 |     (at your option) any later version.
300 | 
301 |     This program is distributed in the hope that it will be useful,
302 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
303 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
304 |     GNU General Public License for more details.
305 | 
306 |     You should have received a copy of the GNU General Public License along
307 |     with this program; if not, write to the Free Software Foundation, Inc.,
308 |     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
309 | 
310 | Also add information on how to contact you by electronic and paper mail.
311 | 
312 | If the program is interactive, make it output a short notice like this
313 | when it starts in an interactive mode:
314 | 
315 |     Gnomovision version 69, Copyright (C) year name of author
316 |     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317 |     This is free software, and you are welcome to redistribute it
318 |     under certain conditions; type `show c' for details.
319 | 
320 | The hypothetical commands `show w' and `show c' should show the appropriate
321 | parts of the General Public License.  Of course, the commands you use may
322 | be called something other than `show w' and `show c'; they could even be
323 | mouse-clicks or menu items--whatever suits your program.
324 | 
325 | You should also get your employer (if you work as a programmer) or your
326 | school, if any, to sign a "copyright disclaimer" for the program, if
327 | necessary.  Here is a sample; alter the names:
328 | 
329 |   Yoyodyne, Inc., hereby disclaims all copyright interest in the program
330 |   `Gnomovision' (which makes passes at compilers) written by James Hacker.
331 | 
332 |   {signature of Ty Coon}, 1 April 1989
333 |   Ty Coon, President of Vice
334 | 
335 | This General Public License does not permit incorporating your program into
336 | proprietary programs.  If your program is a subroutine library, you may
337 | consider it more useful to permit linking proprietary applications with the
338 | library.  If this is what you want to do, use the GNU Lesser General
339 | Public License instead of this License.
340 | 
341 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | CXX=clang++
 2 | CFLAGS=--std=c++14
 3 | LDLIBS=-lpthread
 4 | SOURCES=$(wildcard *.cpp net/*.cpp)
 5 | OBJECTS=$(SOURCES:.cpp=.o)
 6 | EXECUTABLE=evilproxy
 7 | 
 8 | all: $(EXECUTABLE)
 9 | 
10 | $(EXECUTABLE): $(OBJECTS)
11 | 	$(CXX) $^ -o $@ $(LDLIBS)
12 | 
13 | %.o: %.cpp
14 | 	$(CXX) -c $< -o $@ $(CFLAGS)
15 | 
16 | clean:
17 | 	rm $(EXECUTABLE) $(OBJECTS)
18 | 


--------------------------------------------------------------------------------
/Proxy.cpp:
--------------------------------------------------------------------------------
 1 | #include "Proxy.hpp"
 2 | 
 3 | #include <map>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | #include <sstream>
 7 | 
 8 | #include "net/HTTP.hpp"
 9 | 
10 | std::vector<std::string> Proxy::modifyableTypes = {"/html", "/css", "/javascript", "/x-javascript"};
11 | 
12 | Proxy::Proxy(net::TCPSocket &&socket, std::shared_ptr<HTTPTransform> transformations) :
13 |         client(std::move(socket)), transformations(transformations) {
14 | }
15 | 
16 | void Proxy::run() {
17 | 
18 |     try {
19 |         std::string host;
20 | 
21 |         for (;;) {
22 |             net::HTTP request, response;
23 | 
24 |             request.read(client);
25 | 
26 |             // Client could close connection in the meantime
27 |             if (request.getRequestLine().empty())
28 |                 return;
29 | 
30 |             request.getHeaders()["accept-encoding"] = "identity";
31 | 
32 |             if (host.empty()) {
33 |                 host = request.getHeaders()["host"];
34 |                 server.connect(host, "80");
35 |             }
36 | 
37 |             transformations->transformRequest(request);
38 | 
39 |             request.write(server);
40 | 
41 |             response.readRequestLine(server);
42 |             // Server could close connection in the meantime
43 |             if (response.getRequestLine().empty())
44 |                 return;
45 | 
46 |             response.readHeaders(server);
47 | 
48 |             auto contentTypeIt = response.getHeaders().find("content-type");
49 |             if (contentTypeIt != response.getHeaders().end() && std::any_of(modifyableTypes.begin(),
50 |                         modifyableTypes.end(),
51 |                         [&contentTypeIt] (std::string type) {return contentTypeIt->second.find(type) != std::string::npos;})) {
52 |                 response.readContent(server);
53 |                 transformations->transformResponse(response);
54 |                 response.fixContentLength();
55 |                 response.write(client);
56 |             } else {
57 |                 response.writeRequestLine(client);
58 |                 response.writeHeaders(client);
59 | 
60 |                 response.streamContent(server, client);
61 |         }
62 | 
63 |         if (response.getHeaders()["connection"] == "close" ||
64 |                 request.getHeaders()["connection"] == "close" ||
65 |                 !server.canWrite())
66 |             break;
67 |         }
68 | 
69 |     } catch (std::runtime_error er) {
70 |         std::cerr << er.what() << std::endl;
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/Proxy.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <map>
 4 | #include <memory>
 5 | 
 6 | #include "net/TCPSocket.hpp"
 7 | #include "HTTPTransform.hpp"
 8 | 
 9 | class Proxy
10 | {
11 |     public:
12 |         Proxy(net::TCPSocket &&socket, std::shared_ptr<HTTPTransform> transformations);
13 |         void run();
14 |     private:
15 | 
16 |         static std::vector<std::string> modifyableTypes;
17 |         net::TCPSocket client;
18 |         net::TCPSocket server;
19 |         std::shared_ptr<HTTPTransform> transformations;
20 | };
21 | 


--------------------------------------------------------------------------------
/Server.cpp:
--------------------------------------------------------------------------------
 1 | #include "Server.hpp"
 2 | 
 3 | #include <thread>
 4 | 
 5 | #include "Proxy.hpp"
 6 | 
 7 | Server::Server(int port, std::shared_ptr<HTTPTransform> transformations) : transformations(transformations), stopped(false) {
 8 |     socket.bind(port);
 9 |     socket.listen(5);
10 | }
11 | 
12 | void Server::run() {
13 |     while(!stopped) {
14 |         std::thread t(&Proxy::run, Proxy(socket.accept(), transformations));
15 |         t.detach();
16 |     }
17 | }
18 | 
19 | void Server::stop() {
20 |     stopped = true;
21 | }
22 | 


--------------------------------------------------------------------------------
/Server.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <memory>
 4 | 
 5 | #include "HTTPTransform.hpp"
 6 | #include "net/TCPSocket.hpp"
 7 | 
 8 | class Server
 9 | {
10 |     public:
11 |         Server(int port, std::shared_ptr<HTTPTransform> transformations);
12 |         void run();
13 |         void stop();
14 |     private:
15 |         net::TCPSocket socket;
16 |         std::shared_ptr<HTTPTransform> transformations;
17 |         bool stopped;
18 | };
19 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <thread>
 3 | #include <regex>
 4 | #include <memory>
 5 | 
 6 | #include "Server.hpp"
 7 | #include "HTTPTransform.hpp"
 8 | 
 9 | int main(int argc, char **argv) {
10 |     auto transformations = std::make_shared<HTTPTransform>();
11 |     std::thread st(&Server::run, Server(8080, transformations));
12 |     st.detach();
13 | 
14 |     std::string input;
15 | 
16 |     for (;;) {
17 |         std::cin >> input;
18 | 
19 |         if (input == "CLEAR_COOKIES") {
20 |             std::string host;
21 |             std::cin >> host;
22 |             auto fn = [host] (net::HTTP &http) {
23 |                 if (http.getType() == net::HTTP::Type::Response || http.getUrl().find(host) != std::string::npos) {
24 |                     http.getHeaders().erase("cookie");
25 |                     http.getHeaders().erase("set-cookie");
26 |                 }
27 |             };
28 |             transformations->addRequestTransform(fn);
29 |             transformations->addResponseTransform(fn);
30 | 
31 |         } else if (input.compare(0, 4, "EDIT") == 0) {
32 |             std::string reg_str, replace;
33 |             std::cin >> reg_str >> replace;
34 |             std::regex reg(reg_str);
35 |             auto fn = [reg, replace] (net::HTTP &http) {
36 |                 http.getContent() = std::regex_replace(http.getContent(), reg, replace);
37 |             };
38 |             if (input == "EDIT_REQUEST") {
39 |                 transformations->addRequestTransform(fn);
40 |             } else if (input == "EDIT_RESPONSE") {
41 |                 transformations->addResponseTransform(fn);
42 |             }
43 |         } else if (input == "WATCH") {
44 |             std::string host;
45 |             std::cin >> host;
46 |             auto fn = [host] (net::HTTP &http) {
47 |                 auto url = http.getUrl();
48 |                 if (url.find(host) != std::string::npos) {
49 |                     std::cout << "VISITING " << url << std::endl;
50 |                     auto cookie = http.getHeaders().find("cookie");
51 |                     if (cookie != http.getHeaders().end()) {
52 |                         std::cout << "COOKIE " << cookie->second << std::endl;
53 |                     }
54 |                 }
55 |             };
56 |             transformations->addRequestTransform(fn);
57 |         }
58 |     }
59 | 
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/net/HTTP.cpp:
--------------------------------------------------------------------------------
  1 | #include "HTTP.hpp"
  2 | 
  3 | #include <stdexcept>
  4 | #include <string>
  5 | #include <sstream>
  6 | #include <algorithm>
  7 | #include <iostream>
  8 | 
  9 | 
 10 | void net::HTTP::read(net::TCPSocket &socket) {
 11 |     readRequestLine(socket);
 12 |     readHeaders(socket);
 13 |     readContent(socket);
 14 | }
 15 | 
 16 | void net::HTTP::readRequestLine(net::TCPSocket &socket) {
 17 |     requestLine = trim(socket.readLine());
 18 | }
 19 | 
 20 | void net::HTTP::readHeaders(net::TCPSocket &socket) {
 21 |     std::string line;
 22 | 
 23 |     for (;;) {
 24 |         line = trim(socket.readLine());
 25 | 
 26 |         if (line == "")
 27 |             break;
 28 | 
 29 |         int pos = line.find_first_of(":");
 30 |         if (pos == std::string::npos)
 31 |             throw std::runtime_error("Invalid header (" + line + ") " + requestLine);
 32 | 
 33 |         std::string header = trim(line.substr(0, pos));
 34 | 
 35 |         for (auto &x : header)
 36 |             x = tolower(x);
 37 |         std::string value = trim(line.substr(pos+1));
 38 | 
 39 |         headers[header] = value;
 40 |     }
 41 | }
 42 | 
 43 | void net::HTTP::readContent(net::TCPSocket &socket) {
 44 |     int size = 1;
 45 | 
 46 |     if (isChunkedEncoded()) {
 47 | //     Changing chunked transfer to Content-Length - easier content resizing
 48 |         while (size) {
 49 |             std::string line = trim(socket.readLine());
 50 |             std::stringstream converter(line);
 51 |             converter >> std::hex >> size;
 52 |             content += socket.read(size);
 53 |             socket.read(2);
 54 |         }
 55 |         headers.erase("transfer-encoding");
 56 |         std::stringstream converter;
 57 |         converter << content.length();
 58 |         headers["content-length"] = converter.str();
 59 | 
 60 |     } else if (headers.count("content-length")) {
 61 | 
 62 |         std::stringstream converter(headers["content-length"]);
 63 |         converter >> size;
 64 | 
 65 |         content = socket.read(size);
 66 |     } else if (getType() == net::HTTP::Type::Response) {
 67 |         while (socket.canRead())
 68 |             content += socket.read(8192);
 69 |     }
 70 | }
 71 | 
 72 | void net::HTTP::write(net::TCPSocket &socket) {
 73 |     writeRequestLine(socket);
 74 |     writeHeaders(socket);
 75 |     writeContent(socket);
 76 | }
 77 | 
 78 | void net::HTTP::writeRequestLine(net::TCPSocket &socket) {
 79 |     socket.writeLine(requestLine + "\r");
 80 | }
 81 | 
 82 | void net::HTTP::writeHeaders(net::TCPSocket &socket) {
 83 |     for (auto &it : headers)
 84 |         socket.writeLine(it.first + ": " + it.second + "\r");
 85 |     socket.writeLine("\r");
 86 | }
 87 | 
 88 | void net::HTTP::writeContent(net::TCPSocket &socket) {
 89 |     socket.write(content);
 90 | }
 91 | 
 92 | void net::HTTP::streamContent(net::TCPSocket &from, net::TCPSocket &to) {
 93 |     int size = 1;
 94 | 
 95 |     if (isChunkedEncoded()) {
 96 |         while (size) {
 97 | 
 98 |             std::string line = trim(from.readLine());
 99 |             std::stringstream converter(line);
100 |             converter >> std::hex >> size;
101 |             std::string chunk = from.read(size+2);
102 | 
103 |             to.write(line + "\r\n" + chunk);
104 |         }
105 | 
106 |     } else if (headers.count("content-length")) {
107 |         std::stringstream converter(headers["content-length"]);
108 |         converter >> size;
109 | 
110 |         while(size > 0) {
111 |             std::string tmpString = from.read(std::min(8192, size));
112 |             if (!tmpString.length())
113 |                 break;
114 |             to.write(tmpString);
115 |             size -= tmpString.length();
116 |         }
117 |     } else if (getType() == net::HTTP::Type::Response) {
118 |         while (from.canRead()) {
119 |             to.write(from.read(8192));
120 |         }
121 |     }
122 | }
123 | 
124 | void net::HTTP::fixContentLength() {
125 |     std::stringstream converter;
126 |     converter << content.length();
127 |     headers["content-length"] = converter.str();
128 | }
129 | 
130 | std::map<std::string, std::string> & net::HTTP::getHeaders() {
131 |     return headers;
132 | }
133 | 
134 | std::string & net::HTTP::getRequestLine() {
135 |     return requestLine;
136 | }
137 | 
138 | std::string & net::HTTP::getContent() {
139 |     return content;
140 | }
141 | 
142 | std::string net::HTTP::getUrl() const {
143 |     auto a = requestLine.find_first_of(' ') + 1;
144 |     auto url = requestLine.substr(a);
145 |     url = url.substr(0, url.find_first_of(' '));
146 |     return headers.find("host")->second + url;
147 | }
148 | 
149 | net::HTTP::Type net::HTTP::getType() const {
150 |     if (requestLine.substr(0, 4) == "HTTP")
151 |         return net::HTTP::Type::Response;
152 |     else
153 |         return net::HTTP::Type::Request;
154 | }
155 | 
156 | bool net::HTTP::isChunkedEncoded() const {
157 |     auto transfer = headers.find("transfer-encoding");
158 |     return (transfer != headers.end() && transfer->second == "chunked");
159 | }
160 | 
161 | std::string net::HTTP::trim(std::string str) {
162 |     std::string whitespaces = "\r\n\t ";
163 |     str.erase(0, str.find_first_not_of(whitespaces));
164 |     auto pos = str.find_last_not_of(whitespaces);
165 |     if (pos != std::string::npos)
166 |         str.erase(pos+1);
167 |     return str;
168 | }
169 | 


--------------------------------------------------------------------------------
/net/HTTP.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <map>
 4 | 
 5 | #include "TCPSocket.hpp"
 6 | 
 7 | namespace net
 8 | {
 9 |     class HTTP {
10 |         public:
11 |             void read(TCPSocket &socket);
12 |             void readRequestLine(TCPSocket &socket);
13 |             void readHeaders(TCPSocket &socket);
14 |             void readContent(TCPSocket &socket);
15 | 
16 |             void write(TCPSocket &socket);
17 |             void writeRequestLine(TCPSocket &socket);
18 |             void writeHeaders(TCPSocket &socket);
19 |             void writeContent(TCPSocket &socket);
20 | 
21 |             void streamContent(TCPSocket &from, TCPSocket &to);
22 | 
23 |             void fixContentLength();
24 | 
25 |             std::map<std::string, std::string> & getHeaders();
26 |             std::string & getRequestLine();
27 |             std::string & getContent();
28 |             std::string getUrl() const;
29 | 
30 |             enum class Type {Request, Response};
31 |             Type getType() const;
32 |         private:
33 | 
34 |             bool isChunkedEncoded() const;
35 | 
36 |             std::string trim(std::string str);
37 | 
38 |             std::string requestLine;
39 |             std::map<std::string, std::string> headers;
40 |             std::string content;
41 | 
42 |     };
43 | 
44 | }
45 | 


--------------------------------------------------------------------------------
/net/TCPSocket.cpp:
--------------------------------------------------------------------------------
  1 | #include "TCPSocket.hpp"
  2 | 
  3 | #include <iostream>
  4 | #include <stdexcept>
  5 | 
  6 | #include <unistd.h>
  7 | #include <sys/socket.h>
  8 | #include <netinet/in.h>
  9 | #include <netdb.h>
 10 | #include <errno.h>
 11 | 
 12 | net::TCPSocket::TCPSocket() : inputstream(new std::stringstream()) {
 13 |     fd = socket(AF_INET, SOCK_STREAM, 0);
 14 |     if (fd < 0)
 15 |         throw std::runtime_error("socket failed");
 16 |     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (int*)1, sizeof(int));
 17 | }
 18 | 
 19 | 
 20 | net::TCPSocket::TCPSocket(TCPSocket &&x) : fd(x.fd), inputstream(std::move(x.inputstream)) {
 21 |     x.fd = -1;
 22 | }
 23 | 
 24 | net::TCPSocket::TCPSocket(int fd) : fd(fd), inputstream(new std::stringstream()) {
 25 | }
 26 | 
 27 | net::TCPSocket::~TCPSocket() {
 28 |     close();
 29 | }
 30 | 
 31 | bool net::TCPSocket::canRead() const {
 32 |     return fd != -1 || !inputstream->eof();
 33 | }
 34 | 
 35 | bool net::TCPSocket::canWrite() const {
 36 |     return fd != -1;
 37 | }
 38 | 
 39 | void net::TCPSocket::close() {
 40 |     if (fd != -1) {
 41 |         ::close(fd);
 42 |         fd = -1;
 43 |     }
 44 | }
 45 | 
 46 | void net::TCPSocket::bind(int port) {
 47 |     sockaddr_in addr;
 48 |     addr.sin_family = AF_INET;
 49 |     addr.sin_addr.s_addr = INADDR_ANY;
 50 |     addr.sin_port = htons(port);
 51 | 
 52 |     if (::bind(fd, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0)
 53 |         throw std::runtime_error("bind failed");
 54 | }
 55 | 
 56 | void net::TCPSocket::listen(int n) {
 57 |     if (::listen(fd, n) < 0)
 58 |         throw std::runtime_error("listen failed");
 59 | }
 60 | 
 61 | net::TCPSocket net::TCPSocket::accept() {
 62 |     int child = ::accept(fd, nullptr, nullptr);
 63 |     if (child < 0)
 64 |         throw std::runtime_error("accept failed");
 65 |     return TCPSocket(child);
 66 | }
 67 | 
 68 | void net::TCPSocket::connect(const std::string &address, const std::string &port) {
 69 |     addrinfo *res, hints;
 70 | 
 71 |     hints.ai_family = AF_INET;
 72 |     hints.ai_socktype = SOCK_STREAM;
 73 | 
 74 |     if (getaddrinfo(address.c_str(), port.c_str(), nullptr, &res))
 75 |         throw std::runtime_error("cannot resolve " + address);
 76 | 
 77 |     if (::connect(fd, res->ai_addr, res->ai_addrlen) < 0)
 78 |         throw std::runtime_error("connect failed " + address);
 79 | }
 80 | 
 81 | void net::TCPSocket::write(const std::string &data) {
 82 |     int wrote = 0, ret;
 83 |     while (wrote != data.length()) {
 84 |         ret = ::write(fd, data.substr(wrote, std::string::npos).c_str(), data.length()-wrote);
 85 |         if (ret < 0 && errno != EINTR) {
 86 |             std::cerr << "errno is " << errno << std::endl;
 87 |             throw std::runtime_error("write failed");
 88 |         }
 89 |         wrote += ret;
 90 |     }
 91 | }
 92 | 
 93 | void net::TCPSocket::writeLine(const std::string &data) {
 94 |     write(data + "\n");
 95 | }
 96 | 
 97 | std::string net::TCPSocket::read(int amount) {
 98 |     char *buffer = new char[amount+1];
 99 |     int done = 0;
100 | 
101 |     while (done < amount && canRead()) {
102 |         if (inputstream->eof())
103 |             doRead();
104 |         inputstream->read(buffer+done, amount-done);
105 |         done += inputstream->gcount();
106 |     }
107 |     std::string ret = std::string(buffer, done);
108 |     delete buffer;
109 |     return ret;
110 | }
111 | 
112 | std::string net::TCPSocket::readLine() {
113 |     std::string ret, line;
114 | 
115 |     getline(*inputstream, ret);
116 | 
117 |     while(inputstream->eof() && canRead()) {
118 |         doRead();
119 |         getline(*inputstream, line);
120 |         ret += line;
121 |     }
122 | 
123 |     return ret;
124 | }
125 | 
126 | int net::TCPSocket::doRead() {
127 |     if (fd == -1)
128 |         return 0;
129 | 
130 |     char buffer[2049];
131 |     int ret = ::read(fd, buffer, 2048);
132 |     if (ret < 0) {
133 |         std::cerr << "errno is " << errno << std::endl;
134 |         throw std::runtime_error("read error");
135 |     } else if (!ret) {
136 |         close();
137 |     } else {
138 |         if (inputstream->eof()) {
139 |             inputstream->str("");
140 |             inputstream->clear();
141 |         }
142 |         inputstream->write(buffer, ret);
143 |     }
144 |     return ret;
145 | }
146 | 


--------------------------------------------------------------------------------
/net/TCPSocket.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <string>
 4 | #include <sstream>
 5 | #include <memory>
 6 | 
 7 | namespace net
 8 | {
 9 | 
10 |     class TCPSocket
11 |     {
12 |         public:
13 |             TCPSocket();
14 |             TCPSocket(TCPSocket &&x);
15 |             TCPSocket(int fd);
16 |             ~TCPSocket();
17 |             bool canRead() const;
18 |             bool canWrite() const;
19 |             void close();
20 |             void bind(int port);
21 |             void listen(int n);
22 |             TCPSocket accept();
23 |             void connect(const std::string &address, const std::string &port);
24 |             void write(const std::string &data);
25 |             void writeLine(const std::string &data);
26 |             std::string read(int amount);
27 |             std::string readLine();
28 | 
29 |         private:
30 |             int fd;
31 |             std::unique_ptr<std::stringstream> inputstream;
32 | 
33 |             int doRead();
34 |     };
35 | }
36 | 


--------------------------------------------------------------------------------